@saulwade/swl-ses 1.0.0

package/scripts/instalar-git-hook.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Instala un pre-commit hook en el proyecto actual que ejecuta
+ * `swl-ses check-update` en cada commit. Sirve para avisar de nuevas
+ * versiones de SWL independientemente del CLI de IA que use el
+ * desarrollador (Codex, Copilot, Gemini, OpenCode). En Claude Code
+ * ya se cubre vía el hook UserPromptSubmit — este pre-commit es
+ * complementario para los demás runtimes.
+ *
+ * Comportamiento:
+ *   - Detecta .husky/ primero (proyectos con husky) y escribe ahí.
+ *   - Si no hay husky, escribe directamente a .git/hooks/pre-commit.
+ *   - Es idempotente: si ya existe un pre-commit con el marcador
+ *     SWL_CHECK_UPDATE, no duplica. Si existe sin el marcador, NO
+ *     sobreescribe — pide al usuario añadir la línea manualmente.
+ *   - NUNCA bloquea el commit: la línea termina con `|| true` y
+ *     redirige stderr para que falle silenciosamente.
+ *
+ * Uso:
+ *   npx swl-ses@latest install-git-hook
+ *   npx swl-ses@latest install-git-hook --force    (reemplaza hook existente)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const MARCADOR = '# SWL_CHECK_UPDATE — no borrar esta línea';
+const LINEA_CHECK =
+  'npx --no-install swl-ses@latest check-update 2>&1 || true';
+
+function log(msg) { process.stdout.write(msg + '\n'); }
+function warn(msg) { process.stderr.write(msg + '\n'); }
+
+function detectarContexto(cwd) {
+  const gitDir = path.join(cwd, '.git');
+  const huskyDir = path.join(cwd, '.husky');
+
+  if (!fs.existsSync(gitDir)) {
+    return { error: 'No se detectó repo git (.git/ no existe).' };
+  }
+
+  if (fs.existsSync(huskyDir) && fs.statSync(huskyDir).isDirectory()) {
+    return { tipo: 'husky', ruta: path.join(huskyDir, 'pre-commit') };
+  }
+
+  return { tipo: 'git-hooks', ruta: path.join(gitDir, 'hooks', 'pre-commit') };
+}
+
+function plantillaHusky() {
+  return [
+    '#!/usr/bin/env sh',
+    '. "$(dirname -- "$0")/_/husky.sh"',
+    '',
+    MARCADOR,
+    LINEA_CHECK,
+    '',
+  ].join('\n');
+}
+
+function plantillaGit() {
+  return [
+    '#!/bin/sh',
+    MARCADOR,
+    LINEA_CHECK,
+    '',
+  ].join('\n');
+}
+
+function instalar({ force = false, cwd = process.cwd() } = {}) {
+  const ctx = detectarContexto(cwd);
+  if (ctx.error) {
+    warn('[swl-ses] ' + ctx.error);
+    return { ok: false, codigo: 'NO_GIT' };
+  }
+
+  const plantilla = ctx.tipo === 'husky' ? plantillaHusky() : plantillaGit();
+
+  // Caso 1: no existe → crear directo
+  if (!fs.existsSync(ctx.ruta)) {
+    fs.mkdirSync(path.dirname(ctx.ruta), { recursive: true });
+    fs.writeFileSync(ctx.ruta, plantilla, { mode: 0o755 });
+    log(`[swl-ses] pre-commit creado: ${ctx.ruta}`);
+    log('[swl-ses] Este hook avisará de nuevas versiones al hacer commit.');
+    log('[swl-ses] NUNCA bloquea el commit — solo imprime aviso.');
+    return { ok: true, codigo: 'CREADO', ruta: ctx.ruta };
+  }
+
+  const contenido = fs.readFileSync(ctx.ruta, 'utf8');
+
+  // Caso 2: ya instalado → idempotente
+  if (contenido.includes(MARCADOR)) {
+    log(`[swl-ses] pre-commit ya tiene el check de versión: ${ctx.ruta}`);
+    return { ok: true, codigo: 'YA_INSTALADO', ruta: ctx.ruta };
+  }
+
+  // Caso 3: existe pero sin marcador → anexar o reemplazar según force
+  if (force) {
+    fs.writeFileSync(ctx.ruta, plantilla, { mode: 0o755 });
+    log(`[swl-ses] pre-commit reemplazado (--force): ${ctx.ruta}`);
+    return { ok: true, codigo: 'REEMPLAZADO', ruta: ctx.ruta };
+  }
+
+  const anexo =
+    contenido.trimEnd() + '\n\n' + MARCADOR + '\n' + LINEA_CHECK + '\n';
+  fs.writeFileSync(ctx.ruta, anexo, { mode: 0o755 });
+  log(`[swl-ses] check de versión anexado a pre-commit existente: ${ctx.ruta}`);
+  log('[swl-ses] Si quieres revertir, borra las dos últimas líneas del hook.');
+  return { ok: true, codigo: 'ANEXADO', ruta: ctx.ruta };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const force = args.includes('--force');
+  const resultado = instalar({ force });
+  process.exit(resultado.ok ? 0 : 1);
+}
+
+if (require.main === module) main();
+
+module.exports = { instalar, MARCADOR, LINEA_CHECK };

package/scripts/lib/agp-frontmatter.js

@@ -0,0 +1,222 @@
+'use strict';
+
+/**
+ * agp-frontmatter.js
+ *
+ * Parser YAML minimalista y validador de safety invariants para el loop
+ * AGP (Autogenesis Protocol) adoptado por swl-ses.
+ *
+ * Funciones:
+ *   parsearFrontmatter(rutaArchivo)   - lee archivo .md, extrae --- ... ---
+ *   parsearCuerpoYaml(cuerpo)         - parsea solo el cuerpo YAML crudo
+ *   aplicarOperador(actual, op, esp)  - eq/neq/lte/gte/in/not_in
+ *   validarInvariantesDeAgente(nombre, dirs?)
+ *                                      - valida que el frontmatter cumpla
+ *                                        los invariantes declarados
+ *
+ * Zero-deps. Idempotente. Reutilizable por run-skill-evals.js,
+ * hooks/*, y tests unitarios.
+ *
+ * @module scripts/lib/agp-frontmatter
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Parser YAML
+// ---------------------------------------------------------------------------
+
+/**
+ * Lee un archivo .md y extrae su frontmatter YAML como objeto.
+ * @param {string} rutaArchivo  ruta absoluta o relativa al archivo
+ * @returns {object|null}       objeto del frontmatter, o null si no hay
+ */
+function parsearFrontmatter(rutaArchivo) {
+  let raw;
+  try {
+    raw = fs.readFileSync(rutaArchivo, 'utf8');
+  } catch {
+    return null;
+  }
+  const match = raw.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/);
+  if (!match) return null;
+  return parsearCuerpoYaml(match[1]);
+}
+
+/**
+ * Parsea un cuerpo YAML (sin los delimitadores `---`).
+ * Soporta escalares, listas inline, listas multilinea y listas de objetos.
+ *
+ * @param {string} cuerpo
+ * @returns {object}
+ */
+function parsearCuerpoYaml(cuerpo) {
+  const lineas = cuerpo.split(/\r?\n/);
+  const obj = {};
+  let claveLista = null;
+  let lista = null;
+  let itemObjeto = null;
+  let sangriaItem = null;
+
+  const cerrarItemObjeto = () => {
+    if (itemObjeto && lista) {
+      lista.push(itemObjeto);
+      itemObjeto = null;
+    }
+  };
+
+  const cerrarLista = () => {
+    cerrarItemObjeto();
+    if (claveLista && lista) obj[claveLista] = lista;
+    claveLista = null;
+    lista = null;
+    sangriaItem = null;
+  };
+
+  for (const linea of lineas) {
+    if (!linea.trim() || /^\s*#/.test(linea)) continue;
+    const lineaSinComentario = despedirComentario(linea);
+    if (!lineaSinComentario.trim()) continue;
+
+    const mItem = lineaSinComentario.match(/^(\s+)-\s+(.+?)\s*$/);
+    if (mItem && claveLista) {
+      cerrarItemObjeto();
+      sangriaItem = mItem[1].length;
+      const resto = mItem[2];
+      const mKV = resto.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/);
+      if (mKV) {
+        itemObjeto = {};
+        const [, k, v] = mKV;
+        itemObjeto[k] = v.trim() === '' ? null : convertirValor(v.trim());
+      } else {
+        lista.push(convertirValor(resto));
+      }
+      continue;
+    }
+
+    const mSub = lineaSinComentario.match(/^(\s+)([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/);
+    if (mSub && itemObjeto && sangriaItem !== null && mSub[1].length > sangriaItem) {
+      const [, , k, v] = mSub;
+      itemObjeto[k] = parsearValorConListaInline(v.trim());
+      continue;
+    }
+
+    const mCampo = lineaSinComentario.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/);
+    if (!mCampo) continue;
+    cerrarLista();
+    const [, clave, valorRaw] = mCampo;
+    const valorTrim = valorRaw.trim();
+    if (valorTrim === '') {
+      claveLista = clave;
+      lista = [];
+      itemObjeto = null;
+      sangriaItem = null;
+      continue;
+    }
+    obj[clave] = parsearValorConListaInline(valorTrim);
+  }
+  cerrarLista();
+  return obj;
+}
+
+function parsearValorConListaInline(s) {
+  if (s === '' || s === null || s === undefined) return null;
+  if (s.startsWith('[') && s.endsWith(']')) {
+    const contenido = s.slice(1, -1).trim();
+    if (contenido === '') return [];
+    return contenido.split(',').map(x => convertirValor(x.trim()));
+  }
+  return convertirValor(s);
+}
+
+function despedirComentario(linea) {
+  const m = linea.match(/^(.*?)(?:\s+#\s.*)?$/);
+  return m ? m[1] : linea;
+}
+
+function convertirValor(s) {
+  if (s === 'true')  return true;
+  if (s === 'false') return false;
+  if (s === 'null' || s === '~') return null;
+  if (/^-?\d+(\.\d+)?$/.test(s)) return parseFloat(s);
+  return s.replace(/^['"]|['"]$/g, '');
+}
+
+// ---------------------------------------------------------------------------
+// Validador de safety invariants (AGP Commit operator)
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {*} actual   valor actual del campo en el frontmatter
+ * @param {string} operador  eq|neq|lte|gte|in|not_in
+ * @param {*} esperado  valor esperado
+ * @returns {boolean}
+ */
+function aplicarOperador(actual, operador, esperado) {
+  switch (operador) {
+    case 'eq':  return actual === esperado;
+    case 'neq': return actual !== esperado;
+    case 'lte': return typeof actual === 'number' && typeof esperado === 'number' && actual <= esperado;
+    case 'gte': return typeof actual === 'number' && typeof esperado === 'number' && actual >= esperado;
+    case 'in':  return Array.isArray(esperado) && esperado.includes(actual);
+    case 'not_in': return Array.isArray(esperado) && !esperado.includes(actual);
+    default:    return false;
+  }
+}
+
+/**
+ * Busca el agente/skill por nombre y valida los invariantes declarados en su
+ * frontmatter. Si el frontmatter no existe, no tiene campo `invariantes`, o
+ * el archivo no se encuentra, devuelve { ok: true, ... skipped: "..." }.
+ *
+ * @param {string} nombre                  ej "notificador-swl" o "ux-diseno"
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]              directorio base (default: process.cwd())
+ * @returns {{ ok: boolean, violaciones: Array, skipped?: string }}
+ */
+function validarInvariantesDeAgente(nombre, opts = {}) {
+  const base = opts.cwd || process.cwd();
+  const candidatos = [
+    path.join(base, 'agentes', `${nombre}.md`),
+    path.join(base, 'habilidades', nombre, 'SKILL.md'),
+  ];
+  let rutaArchivo = null;
+  for (const c of candidatos) {
+    if (fs.existsSync(c)) { rutaArchivo = c; break; }
+  }
+  if (!rutaArchivo) {
+    return { ok: true, violaciones: [], skipped: `archivo no encontrado para ${nombre}` };
+  }
+  const fm = parsearFrontmatter(rutaArchivo);
+  if (!fm) {
+    return { ok: true, violaciones: [], skipped: `frontmatter no parseable en ${rutaArchivo}` };
+  }
+  const invariantes = Array.isArray(fm.invariantes) ? fm.invariantes : [];
+  if (invariantes.length === 0) {
+    return { ok: true, violaciones: [], skipped: 'sin invariantes declarados' };
+  }
+  const violaciones = [];
+  for (const inv of invariantes) {
+    if (!inv || typeof inv !== 'object') continue;
+    const actual = fm[inv.campo];
+    if (!aplicarOperador(actual, inv.operador, inv.valor)) {
+      violaciones.push({
+        campo:    inv.campo,
+        operador: inv.operador,
+        esperado: inv.valor,
+        actual,
+        razon:    inv.razon || null,
+      });
+    }
+  }
+  return { ok: violaciones.length === 0, violaciones };
+}
+
+module.exports = {
+  parsearFrontmatter,
+  parsearCuerpoYaml,
+  aplicarOperador,
+  validarInvariantesDeAgente,
+  convertirValor,
+};

package/scripts/lib/append-con-marcadores.js

@@ -0,0 +1,199 @@
+'use strict';
+
+/**
+ * append-con-marcadores.js — Gestión idempotente de bloques dentro de archivos
+ * markdown del usuario.
+ *
+ * Inserta o reemplaza un bloque delimitado por `beginTag` y `endTag` dentro
+ * de un archivo, sin tocar el resto del contenido. Cubre 4 escenarios:
+ *
+ *   1. El archivo no existe            → crearlo con solo el bloque.
+ *   2. El archivo existe sin marcadores → hacer append del bloque al final.
+ *   3. El archivo existe con marcadores → reemplazar solo el contenido entre ellos.
+ *   4. Marcadores mal formados         → error explícito, no se toca el archivo.
+ *
+ * Escritura atómica vía rename. Nunca corrompe el archivo original.
+ *
+ * Uso típico:
+ *   const { mergeConMarcadores } = require('./lib/append-con-marcadores');
+ *   const resultado = mergeConMarcadores('/ruta/CLAUDE.md', contenidoBloque, {
+ *     beginTag: '<!-- SWL-BEGIN v5.11.0 -->',
+ *     endTag:   '<!-- SWL-END -->',
+ *   });
+ *   // resultado.accion: 'creado' | 'append' | 'reemplazado' | 'sin-cambios' | 'error'
+ *
+ * Zero-deps, Node 18+, CRLF-safe.
+ *
+ * @module scripts/lib/append-con-marcadores
+ */
+
+const fs     = require('fs');
+const path   = require('path');
+const crypto = require('crypto');
+
+const DEFAULT_BEGIN_PREFIX = '<!-- SWL-BEGIN';
+const DEFAULT_END_TAG      = '<!-- SWL-END -->';
+
+/**
+ * Escapa una cadena para uso literal en regex.
+ */
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Construye el bloque completo con marcadores y contenido.
+ * Incluye salto de línea antes/después para separarlo del resto.
+ */
+function ensamblarBloque(beginTag, endTag, contenido) {
+  return `${beginTag}\n${contenido.trimEnd()}\n${endTag}`;
+}
+
+/**
+ * Detecta si el archivo ya contiene un bloque SWL previo (de cualquier versión).
+ * Devuelve el rango { start, end } (índices de caracteres en el texto), o null.
+ *
+ * Busca líneas que empiecen con beginPrefix (p.ej. `<!-- SWL-BEGIN`) y terminen
+ * con endTag literal. El regex cubre varias versiones intermedias.
+ */
+function localizarBloquePrevio(texto, beginPrefix, endTag) {
+  const rePatron = new RegExp(
+    `${escapeRegex(beginPrefix)}[^\\r\\n]*[\\r\\n]+[\\s\\S]*?${escapeRegex(endTag)}`,
+    'm',
+  );
+  const m = texto.match(rePatron);
+  if (!m) return null;
+  return { start: m.index, end: m.index + m[0].length };
+}
+
+/**
+ * Escribe contenido de forma atómica (temp file + rename).
+ * El rename es atómico en el mismo filesystem.
+ */
+function escrituraAtomica(archivoPath, contenido) {
+  const dir = path.dirname(archivoPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const suffix  = crypto.randomBytes(4).toString('hex');
+  const tmpPath = path.join(dir, `.${path.basename(archivoPath)}.${suffix}.tmp`);
+
+  try {
+    fs.writeFileSync(tmpPath, contenido, 'utf8');
+    fs.renameSync(tmpPath, archivoPath);
+  } catch (err) {
+    try { fs.unlinkSync(tmpPath); } catch {}
+    throw err;
+  }
+}
+
+/**
+ * Fusiona `contenidoBloque` dentro de `archivoPath` gestionando los marcadores.
+ *
+ * @param {string} archivoPath - Ruta absoluta del archivo destino.
+ * @param {string} contenidoBloque - Contenido a colocar entre los marcadores (sin incluirlos).
+ * @param {object} [opciones]
+ * @param {string} [opciones.beginTag=`<!-- SWL-BEGIN -->`] - Marcador de inicio.
+ * @param {string} [opciones.endTag=`<!-- SWL-END -->`] - Marcador de fin.
+ * @param {string} [opciones.beginPrefix=`<!-- SWL-BEGIN`] - Prefijo usado para
+ *   detectar bloques de versiones previas. Útil cuando beginTag incluye versión
+ *   (p.ej. `<!-- SWL-BEGIN v5.11.0 -->`) y quieres que la próxima actualización
+ *   reemplace también `<!-- SWL-BEGIN v5.10.5 -->`.
+ * @param {boolean} [opciones.crearSiNoExiste=true] - Si el archivo no existe, créalo.
+ * @returns {{accion: string, archivo: string, bytesEscritos?: number, detalle?: string}}
+ *   accion ∈ { 'creado', 'append', 'reemplazado', 'sin-cambios', 'error' }
+ */
+function mergeConMarcadores(archivoPath, contenidoBloque, opciones = {}) {
+  const beginTag   = opciones.beginTag   || `${DEFAULT_BEGIN_PREFIX} -->`;
+  const endTag     = opciones.endTag     || DEFAULT_END_TAG;
+  const beginPrefix = opciones.beginPrefix || DEFAULT_BEGIN_PREFIX;
+  const crearSiNoExiste = opciones.crearSiNoExiste !== false;
+
+  const bloqueCompleto = ensamblarBloque(beginTag, endTag, contenidoBloque);
+
+  // Caso 1: archivo no existe
+  if (!fs.existsSync(archivoPath)) {
+    if (!crearSiNoExiste) {
+      return { accion: 'error', archivo: archivoPath, detalle: 'archivo-no-existe-y-crear-deshabilitado' };
+    }
+    try {
+      escrituraAtomica(archivoPath, bloqueCompleto + '\n');
+      return { accion: 'creado', archivo: archivoPath, bytesEscritos: Buffer.byteLength(bloqueCompleto, 'utf8') };
+    } catch (err) {
+      return { accion: 'error', archivo: archivoPath, detalle: err.message };
+    }
+  }
+
+  // Leer contenido actual
+  let texto;
+  try {
+    texto = fs.readFileSync(archivoPath, 'utf8');
+  } catch (err) {
+    return { accion: 'error', archivo: archivoPath, detalle: 'read-error: ' + err.message };
+  }
+
+  // Caso 3: ya hay un bloque SWL (cualquier versión)
+  const rango = localizarBloquePrevio(texto, beginPrefix, endTag);
+  if (rango) {
+    const bloqueActual = texto.slice(rango.start, rango.end);
+    if (bloqueActual === bloqueCompleto) {
+      return { accion: 'sin-cambios', archivo: archivoPath };
+    }
+    const nuevo = texto.slice(0, rango.start) + bloqueCompleto + texto.slice(rango.end);
+    try {
+      escrituraAtomica(archivoPath, nuevo);
+      return { accion: 'reemplazado', archivo: archivoPath, bytesEscritos: Buffer.byteLength(nuevo, 'utf8') };
+    } catch (err) {
+      return { accion: 'error', archivo: archivoPath, detalle: 'write-error: ' + err.message };
+    }
+  }
+
+  // Caso 2: archivo existe sin marcadores — append al final
+  const sep = texto.endsWith('\n\n') ? '' : (texto.endsWith('\n') ? '\n' : '\n\n');
+  const nuevo = texto + sep + bloqueCompleto + '\n';
+  try {
+    escrituraAtomica(archivoPath, nuevo);
+    return { accion: 'append', archivo: archivoPath, bytesEscritos: Buffer.byteLength(nuevo, 'utf8') };
+  } catch (err) {
+    return { accion: 'error', archivo: archivoPath, detalle: 'write-error: ' + err.message };
+  }
+}
+
+/**
+ * Elimina un bloque SWL existente del archivo (útil para /swl:uninstall).
+ * Si no hay bloque, retorna sin-cambios. Si el bloque queda como único
+ * contenido del archivo, elimina el archivo.
+ */
+function eliminarBloque(archivoPath, opciones = {}) {
+  const endTag      = opciones.endTag     || DEFAULT_END_TAG;
+  const beginPrefix = opciones.beginPrefix || DEFAULT_BEGIN_PREFIX;
+
+  if (!fs.existsSync(archivoPath)) {
+    return { accion: 'sin-cambios', archivo: archivoPath, detalle: 'archivo-no-existe' };
+  }
+  let texto;
+  try {
+    texto = fs.readFileSync(archivoPath, 'utf8');
+  } catch (err) {
+    return { accion: 'error', archivo: archivoPath, detalle: err.message };
+  }
+
+  const rango = localizarBloquePrevio(texto, beginPrefix, endTag);
+  if (!rango) return { accion: 'sin-cambios', archivo: archivoPath };
+
+  const antes = texto.slice(0, rango.start).trimEnd();
+  const despues = texto.slice(rango.end).trimStart();
+  const nuevo = (antes && despues) ? `${antes}\n\n${despues}\n` : (antes || despues || '');
+
+  if (!nuevo.trim()) {
+    try { fs.unlinkSync(archivoPath); } catch {}
+    return { accion: 'archivo-eliminado', archivo: archivoPath };
+  }
+  try {
+    escrituraAtomica(archivoPath, nuevo.endsWith('\n') ? nuevo : nuevo + '\n');
+    return { accion: 'bloque-eliminado', archivo: archivoPath };
+  } catch (err) {
+    return { accion: 'error', archivo: archivoPath, detalle: err.message };
+  }
+}
+
+module.exports = { mergeConMarcadores, eliminarBloque, localizarBloquePrevio };

package/scripts/lib/artefactos-python.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * artefactos-python.js — fuente única de verdad para los artefactos
+ * Python que NO deben distribuirse en el paquete npm.
+ *
+ * Por qué existe:
+ *   Tanto `scripts/limpiar-artefactos-python.js` (prepack) como
+ *   `scripts/publicar.js` (copiarDir hacia tmpDir del mirror GH)
+ *   necesitan saber qué directorios y extensiones excluir. Tener la
+ *   lista hardcodeada en cada archivo es violación DRY de conocimiento
+ *   — agregar `.pyd` o `.mypy_cache_v2` exigiría editar dos archivos
+ *   y mantenerlos sincronizados.
+ */
+
+const DIRS_ARTEFACTOS_PYTHON = Object.freeze(new Set([
+  '__pycache__',
+  '.pytest_cache',
+  '.mypy_cache',
+  '.ruff_cache',
+]));
+
+const EXTS_ARTEFACTOS_PYTHON = Object.freeze(new Set([
+  '.pyc',
+  '.pyo',
+]));
+
+function esDirArtefacto(nombre) {
+  return DIRS_ARTEFACTOS_PYTHON.has(nombre);
+}
+
+function esArchivoArtefacto(nombre) {
+  const dot = nombre.lastIndexOf('.');
+  if (dot < 0) return false;
+  return EXTS_ARTEFACTOS_PYTHON.has(nombre.slice(dot).toLowerCase());
+}
+
+module.exports = {
+  DIRS_ARTEFACTOS_PYTHON,
+  EXTS_ARTEFACTOS_PYTHON,
+  esDirArtefacto,
+  esArchivoArtefacto,
+};