@saulwade/swl-ses 1.0.0

package/scripts/lib/transformadores/base.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class TransformadorBase {
+  constructor(runtimeConfig) {
+    this.runtime = runtimeConfig;
+  }
+
+  // Parsea frontmatter YAML de un archivo markdown
+  // Retorna { frontmatter: object, cuerpo: string }
+  parsearFrontmatter(contenido) {
+    const match = contenido.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
+      if (valor === 'true') valor = true;
+      else if (valor === 'false') valor = false;
+      // Numbers
+      else if (/^\d+$/.test(valor)) valor = parseInt(valor, 10);
+      frontmatter[clave] = valor;
+    }
+
+    return { frontmatter, cuerpo };
+  }
+
+  // Reconstruye un archivo markdown con frontmatter
+  construirMarkdown(frontmatter, cuerpo) {
+    const lineas = ['---'];
+    for (const [clave, valor] of Object.entries(frontmatter)) {
+      lineas.push(`${clave}: ${valor}`);
+    }
+    lineas.push('---');
+    lineas.push(cuerpo);
+    return lineas.join('\n');
+  }
+
+  // --- Métodos que cada target DEBE implementar ---
+
+  transformarAgente(contenidoMd, metadatos) {
+    throw new Error(`${this.constructor.name} debe implementar transformarAgente()`);
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    throw new Error(`${this.constructor.name} debe implementar transformarSkill()`);
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    throw new Error(`${this.constructor.name} debe implementar transformarRegla()`);
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    throw new Error(`${this.constructor.name} debe implementar transformarComando()`);
+  }
+
+  generarArchivoInstrucciones(contexto) {
+    throw new Error(`${this.constructor.name} debe implementar generarArchivoInstrucciones()`);
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    throw new Error(`${this.constructor.name} debe implementar transformarHooks()`);
+  }
+
+  // Indica si el target soporta un tipo de componente
+  soportaTipo(tipo) {
+    return true;
+  }
+}
+
+module.exports = TransformadorBase;

package/scripts/lib/transformadores/claude.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const TransformadorBase = require('./base');
+
+class TransformadorClaude extends TransformadorBase {
+  transformarAgente(contenidoMd, metadatos) {
+    // Pass-through: Claude soporta el formato SWL directamente
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `agents/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    // Pass-through: copiar directorio completo
+    return {
+      tipo: 'directorio',
+      rutaRelativa: `skills/${metadatos.nombreDirectorio}`,
+    };
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `rules/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `commands/swl/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  /**
+   * Genera el bloque SWL para insertar en el CLAUDE.md del proyecto destino.
+   *
+   * A diferencia de los otros transformadores (codex/gemini/copilot/opencode)
+   * que generan el archivo completo de instrucciones desde cero, Claude usa
+   * un CLAUDE.md que el usuario mantiene y que puede tener contenido propio
+   * (reglas del proyecto, convenciones, notas). Por eso:
+   *
+   *   - El contenido devuelto es un BLOQUE (no archivo completo)
+   *   - Se devuelve `merge: { tipo: 'marcadores', ... }` para indicar al
+   *     caller que debe usar `append-con-marcadores` en lugar de writeFileSync
+   *   - Los marcadores `<!-- SWL-BEGIN vX.Y.Z -->` / `<!-- SWL-END -->`
+   *     permiten que la siguiente actualización reemplace solo este bloque
+   *     sin tocar el contenido del usuario
+   *
+   * El bloque es CONCISO a propósito: apunta a `.claude/` y a los comandos
+   * `/swl:*` en lugar de replicar el contenido completo del sistema. Objetivo:
+   * que Claude sepa que el sistema SWL está instalado y debe priorizarlo,
+   * sin inflar el CLAUDE.md del proyecto.
+   */
+  generarArchivoInstrucciones(contexto) {
+    const fecha = new Date().toISOString().split('T')[0];
+    const lineas = [
+      `> Gestionado por swl-ses v${contexto.version} — no editar entre estos marcadores.`,
+      `> Regenerado en ${fecha} con perfil \`${contexto.perfil || 'default'}\`.`,
+      `> Para excluir este bloque en futuras actualizaciones: \`npx swl-ses@latest install --no-claudemd\`.`,
+      '',
+      '## Sistema SWL — uso obligatorio',
+      '',
+      `Este proyecto usa swl-ses v${contexto.version} (sistema de ingeniería de software auto-evolutivo multi-runtime).`,
+      `Componentes instalados: ${contexto.conteos?.agentes || 0} agentes, ${contexto.conteos?.skills || 0} skills, ${contexto.conteos?.comandos || 0} comandos, ${contexto.conteos?.reglas || 0} reglas.`,
+      '',
+      '### Reglas de máxima prioridad',
+      '',
+      '1. **Idioma: español de México** — respuestas, código comentado, commits, PRs y docs. Evitar anglicismos innecesarios.',
+      '2. **Usar el sistema SWL** — invocar agentes especializados (`orquestador-swl`, `implementador-swl`, `depurador-swl`, etc.) en lugar de hacer trabajo directo. Cargar skills con `Skill("nombre")` antes de implementar. Usar comandos `/swl:*` cuando apliquen.',
+      '3. **Investigar antes de editar** — leer el archivo completo y entender el contexto antes de modificar código.',
+      '4. **Lectura de documentos Office/Jupyter** — usar `python scripts/vendor/markitdown/cli.py <archivo>` para `.docx`, `.xlsx`, `.pptx`, `.ipynb`. El Read tool no soporta esos formatos.',
+      '',
+      '### Dónde están los componentes',
+      '',
+      '- Agentes: `.claude/agents/*.md`',
+      '- Skills: `.claude/skills/*/SKILL.md` (invocar con `Skill("nombre")`)',
+      '- Comandos: `.claude/commands/swl/*.md` (invocar con `/swl:nombre`)',
+      '- Reglas: `.claude/rules/*.md` (se cargan automáticamente)',
+      '- Hooks: registrados en `.claude/settings.json`',
+      '',
+      '### Flujos recomendados',
+      '',
+      '- **Feature completa**: `/swl:discutir-fase N` → `/swl:planear-fase N` → `/swl:ejecutar-fase N` → `/swl:verificar`',
+      '- **Debugging**: delegar a `depurador-swl` con método científico (reproducir → aislar → hipótesis → fix → verificar)',
+      '- **Calidad**: `/swl:revisar` (código) + `revisor-seguridad-swl` antes de merge a main',
+      '- **Aprendizaje continuo**: `/swl:aprender` al final de fase, `/swl:evolucionar` ante fallos recurrentes de agentes',
+      '',
+      '### Consulta del sistema',
+      '',
+      '- `/swl:ayuda` — catálogo completo de comandos',
+      '- `/swl:salud` — diagnóstico de integridad',
+      '- `/swl:metricas` — tokens, costo y modelos usados en la sesión',
+      '- `/swl:skill-search <keyword>` — buscar skills relevantes',
+      '',
+      '### Convenciones de versionado y commits',
+      '',
+      '- Versionado semántico estricto (SemVer)',
+      '- Mensajes de commit en español, formato `<tipo>(<scope>): <descripción en imperativo>`',
+      '- Commits atómicos (un cambio lógico = un commit)',
+      '- Antes de release: `/swl:release` y gate `node scripts/verificar-release.js`',
+    ];
+
+    return {
+      contenido: lineas.join('\n'),
+      rutaRelativa: 'CLAUDE.md',
+      dirBase: '.',
+      merge: {
+        tipo: 'marcadores',
+        beginTag: `<!-- SWL-BEGIN v${contexto.version} — bloque gestionado por swl-ses -->`,
+        endTag: '<!-- SWL-END -->',
+        beginPrefix: '<!-- SWL-BEGIN',
+      },
+    };
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    // Los hooks de Claude se manejan via hooks-settings.js existente
+    return { formato: 'claude-settings', config: hooksConfig };
+  }
+}
+
+module.exports = TransformadorClaude;

package/scripts/lib/transformadores/codex.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const TransformadorBase = require('./base');
+
+class TransformadorCodex extends TransformadorBase {
+  transformarAgente(contenidoMd, metadatos) {
+    // Codex no soporta agentes individuales
+    // Retornar contenido para consolidación
+    return {
+      contenido: contenidoMd,
+      consolidar: true,
+      rutaRelativa: 'AGENTS.md',
+      dirBase: '.',
+    };
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    // Codex NO soporta skills
+    return null;
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    // Consolidar en AGENTS.md
+    return {
+      contenido: contenidoMd,
+      consolidar: true,
+      rutaRelativa: 'AGENTS.md',
+      dirBase: '.',
+    };
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    // Codex NO soporta comandos
+    return null;
+  }
+
+  generarArchivoInstrucciones(contexto) {
+    const lineas = [];
+    lineas.push('# AGENTS.md — Sistema SWL');
+    lineas.push('');
+    lineas.push(`> Generado por swl-ses v${contexto.version} — ${new Date().toISOString().split('T')[0]}`);
+    lineas.push('> NO editar manualmente. Regenerar con: npx swl-ses@latest install --target codex');
+    lineas.push('');
+    lineas.push(`Sistema: swl-ses v${contexto.version}`);
+    lineas.push(`Perfil: ${contexto.perfil}`);
+    lineas.push('');
+
+    // Tabla de agentes
+    if (contexto.agentes && contexto.agentes.length > 0) {
+      lineas.push('## Agentes disponibles');
+      lineas.push('');
+      lineas.push('| Agente | Descripción |');
+      lineas.push('|--------|-------------|');
+      for (const ag of contexto.agentes) {
+        const { frontmatter } = this.parsearFrontmatter(ag.contenido);
+        const nombre = frontmatter.name || ag.nombre || 'sin-nombre';
+        const desc = frontmatter.description || '';
+        const descCorta = desc.length > 100 ? desc.slice(0, 97) + '...' : desc;
+        lineas.push(`| ${nombre} | ${descCorta} |`);
+      }
+      lineas.push('');
+    }
+
+    // Reglas (solo las core, concatenadas)
+    if (contexto.reglas && contexto.reglas.length > 0) {
+      lineas.push('## Reglas obligatorias');
+      lineas.push('');
+      for (const regla of contexto.reglas) {
+        lineas.push(regla.contenido);
+        lineas.push('');
+        lineas.push('---');
+        lineas.push('');
+      }
+    }
+
+    // Skills (solo resumen)
+    if (contexto.skills && contexto.skills.length > 0) {
+      lineas.push('## Skills disponibles (referencia)');
+      lineas.push('');
+      lineas.push('| Skill | Descripción |');
+      lineas.push('|-------|-------------|');
+      for (const sk of contexto.skills) {
+        lineas.push(`| ${sk.nombre} | ${sk.descripcion || ''} |`);
+      }
+      lineas.push('');
+    }
+
+    let resultado = lineas.join('\n');
+
+    // Limitar a 50KB
+    const MAX_SIZE = 50 * 1024;
+    if (Buffer.byteLength(resultado, 'utf-8') > MAX_SIZE) {
+      // Truncar reglas si excede
+      const aviso = '\n\n> **Nota**: Contenido truncado por límite de tamaño. Instalar con perfil más específico para reducir el tamaño.\n';
+      resultado = resultado.slice(0, MAX_SIZE - 200) + aviso;
+    }
+
+    return {
+      contenido: resultado,
+      rutaRelativa: 'AGENTS.md',
+      dirBase: '.',
+    };
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    // Codex NO soporta hooks
+    return null;
+  }
+
+  soportaTipo(tipo) {
+    return ['agentes', 'reglas'].includes(tipo);
+  }
+}
+
+module.exports = TransformadorCodex;

package/scripts/lib/transformadores/copilot.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const TransformadorBase = require('./base');
+
+class TransformadorCopilot extends TransformadorBase {
+  transformarAgente(contenidoMd, metadatos) {
+    // Copilot soporta .github/agents/*.md pero con frontmatter limitado
+    const { frontmatter, cuerpo } = this.parsearFrontmatter(contenidoMd);
+
+    // Solo conservar campos soportados por Copilot
+    const fmCopilot = {};
+    if (frontmatter.name) fmCopilot.name = frontmatter.name;
+    if (frontmatter.description) fmCopilot.description = frontmatter.description;
+
+    return {
+      contenido: this.construirMarkdown(fmCopilot, cuerpo),
+      rutaRelativa: `agents/${metadatos.nombreArchivo}`,
+      // Copilot usa .github/ como base, no .copilot/
+      dirBase: '.github',
+    };
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    // Copilot NO soporta skills nativamente
+    return null;
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    // Las reglas se consolidan en copilot-instructions.md
+    // Retornar contenido para consolidación posterior
+    return {
+      contenido: contenidoMd,
+      consolidar: true,
+      rutaRelativa: 'copilot-instructions.md',
+      dirBase: '.github',
+    };
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    // Copilot NO soporta comandos
+    return null;
+  }
+
+  generarArchivoInstrucciones(contexto) {
+    // Consolidar todas las reglas en un solo archivo
+    const lineas = [];
+    lineas.push('# Instrucciones del proyecto — SWL');
+    lineas.push('');
+    lineas.push(`> Generado por swl-ses v${contexto.version} — ${new Date().toISOString().split('T')[0]}`);
+    lineas.push('> NO editar manualmente. Regenerar con: npx swl-ses@latest install --target copilot');
+    lineas.push('');
+
+    if (contexto.reglas && contexto.reglas.length > 0) {
+      for (const regla of contexto.reglas) {
+        lineas.push(regla.contenido);
+        lineas.push('');
+        lineas.push('---');
+        lineas.push('');
+      }
+    }
+
+    if (contexto.agentes && contexto.agentes.length > 0) {
+      lineas.push('## Agentes disponibles');
+      lineas.push('');
+      lineas.push('| Agente | Descripción |');
+      lineas.push('|--------|-------------|');
+      for (const ag of contexto.agentes) {
+        const { frontmatter } = this.parsearFrontmatter(ag.contenido);
+        const nombre = frontmatter.name || ag.nombre || 'sin-nombre';
+        const desc = frontmatter.description || '';
+        // Truncar description para tabla
+        const descCorta = desc.length > 80 ? desc.slice(0, 77) + '...' : desc;
+        lineas.push(`| ${nombre} | ${descCorta} |`);
+      }
+      lineas.push('');
+    }
+
+    if (contexto.skills && contexto.skills.length > 0) {
+      lineas.push('## Skills disponibles');
+      lineas.push('');
+      lineas.push('| Skill | Descripción |');
+      lineas.push('|-------|-------------|');
+      for (const sk of contexto.skills) {
+        lineas.push(`| ${sk.nombre} | ${sk.descripcion || ''} |`);
+      }
+      lineas.push('');
+    }
+
+    return {
+      contenido: lineas.join('\n'),
+      rutaRelativa: 'copilot-instructions.md',
+      dirBase: '.github',
+    };
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    // Copilot NO soporta hooks
+    return null;
+  }
+
+  soportaTipo(tipo) {
+    return ['agentes', 'reglas'].includes(tipo);
+  }
+}
+
+module.exports = TransformadorCopilot;

package/scripts/lib/transformadores/gemini.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const TransformadorBase = require('./base');
+
+class TransformadorGemini extends TransformadorBase {
+  transformarAgente(contenidoMd, metadatos) {
+    // Gemini soporta frontmatter similar a Claude
+    const { frontmatter, cuerpo } = this.parsearFrontmatter(contenidoMd);
+
+    // Conservar campos compatibles
+    const fmGemini = {};
+    if (frontmatter.name) fmGemini.name = frontmatter.name;
+    if (frontmatter.description) fmGemini.description = frontmatter.description;
+    if (frontmatter.tools) fmGemini.tools = frontmatter.tools;
+    if (frontmatter.model) fmGemini.model = frontmatter.model;
+
+    return {
+      contenido: this.construirMarkdown(fmGemini, cuerpo),
+      rutaRelativa: `agents/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    return {
+      tipo: 'directorio',
+      rutaRelativa: `skills/${metadatos.nombreDirectorio}`,
+    };
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `rules/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `commands/swl/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  generarArchivoInstrucciones(contexto) {
+    const lineas = [];
+    lineas.push('# GEMINI.md — Sistema SWL');
+    lineas.push('');
+    lineas.push(`> Generado por swl-ses v${contexto.version} — ${new Date().toISOString().split('T')[0]}`);
+    lineas.push('> NO editar manualmente. Regenerar con: npx swl-ses@latest install --target gemini');
+    lineas.push('');
+    lineas.push(`Este proyecto usa el sistema SWL con perfil "${contexto.perfil}".`);
+    lineas.push('');
+    lineas.push(`- Agentes: ${contexto.conteos.agentes}`);
+    lineas.push(`- Skills: ${contexto.conteos.skills}`);
+    lineas.push(`- Reglas: ${contexto.conteos.reglas}`);
+    lineas.push(`- Comandos: ${contexto.conteos.comandos}`);
+    lineas.push('');
+    lineas.push('Los agentes están en `.gemini/agents/`, los skills en `.gemini/skills/`.');
+    lineas.push('');
+
+    return {
+      contenido: lineas.join('\n'),
+      rutaRelativa: 'GEMINI.md',
+      dirBase: '.',
+    };
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    // Gemini usa settings.json con formato similar a Claude
+    return { formato: 'gemini-settings', config: hooksConfig };
+  }
+}
+
+module.exports = TransformadorGemini;

package/scripts/lib/transformadores/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const TransformadorClaude = require('./claude');
+const TransformadorCopilot = require('./copilot');
+const TransformadorOpenCode = require('./opencode');
+const TransformadorCodex = require('./codex');
+const TransformadorGemini = require('./gemini');
+
+const TRANSFORMADORES = {
+  claude: TransformadorClaude,
+  openclaude: TransformadorClaude,  // OpenClaude usa formato 100% compatible con Claude Code
+  copilot: TransformadorCopilot,
+  opencode: TransformadorOpenCode,
+  codex: TransformadorCodex,
+  gemini: TransformadorGemini,
+};
+
+function obtenerTransformador(targetId, runtimeConfig) {
+  const Clase = TRANSFORMADORES[targetId];
+  if (!Clase) {
+    throw new Error(
+      `No existe transformador para target "${targetId}". Disponibles: ${Object.keys(TRANSFORMADORES).join(', ')}`
+    );
+  }
+  return new Clase(runtimeConfig || {});
+}
+
+function listarTransformadores() {
+  return Object.keys(TRANSFORMADORES);
+}
+
+module.exports = {
+  obtenerTransformador,
+  listarTransformadores,
+};

package/scripts/lib/transformadores/opencode.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const TransformadorBase = require('./base');
+
+class TransformadorOpenCode extends TransformadorBase {
+  transformarAgente(contenidoMd, metadatos) {
+    // OpenCode soporta frontmatter similar a Claude
+    const { frontmatter, cuerpo } = this.parsearFrontmatter(contenidoMd);
+
+    // Conservar campos compatibles con Agent Skills standard
+    const fmOpenCode = {};
+    if (frontmatter.name) fmOpenCode.name = frontmatter.name;
+    if (frontmatter.description) fmOpenCode.description = frontmatter.description;
+    if (frontmatter.tools) fmOpenCode.tools = frontmatter.tools;
+    if (frontmatter.model) fmOpenCode.model = frontmatter.model;
+
+    return {
+      contenido: this.construirMarkdown(fmOpenCode, cuerpo),
+      rutaRelativa: `agents/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarSkill(dirSkill, metadatos) {
+    // OpenCode sigue Agent Skills standard
+    return {
+      tipo: 'directorio',
+      rutaRelativa: `skills/${metadatos.nombreDirectorio}`,
+    };
+  }
+
+  transformarRegla(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `rules/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  transformarComando(contenidoMd, metadatos) {
+    return {
+      contenido: contenidoMd,
+      rutaRelativa: `commands/swl/${metadatos.nombreArchivo}`,
+    };
+  }
+
+  generarArchivoInstrucciones(contexto) {
+    const lineas = [];
+    lineas.push('# AGENTS.md — Sistema SWL');
+    lineas.push('');
+    lineas.push(`> Generado por swl-ses v${contexto.version} — ${new Date().toISOString().split('T')[0]}`);
+    lineas.push('> NO editar manualmente. Regenerar con: npx swl-ses@latest install --target opencode');
+    lineas.push('');
+    lineas.push(`Este proyecto usa el sistema SWL con perfil "${contexto.perfil}".`);
+    lineas.push('');
+    lineas.push(`- Agentes: ${contexto.conteos.agentes}`);
+    lineas.push(`- Skills: ${contexto.conteos.skills}`);
+    lineas.push(`- Reglas: ${contexto.conteos.reglas}`);
+    lineas.push(`- Comandos: ${contexto.conteos.comandos}`);
+    lineas.push('');
+    lineas.push('Los agentes están en `.opencode/agents/`, los skills en `.opencode/skills/`.');
+    lineas.push('');
+
+    return {
+      contenido: lineas.join('\n'),
+      rutaRelativa: 'AGENTS.md',
+      dirBase: '.',
+    };
+  }
+
+  transformarHooks(hooksConfig, opciones) {
+    // OpenCode usa config.json con formato similar a Claude
+    return { formato: 'opencode-config', config: hooksConfig };
+  }
+}
+
+module.exports = TransformadorOpenCode;