@saulwade/swl-ses 1.3.2 → 1.3.3

package/scripts/generar-skills-lock.js

@@ -1,190 +1,190 @@
-#!/usr/bin/env node
-/**
- * generar-skills-lock.js
- *
- * Genera `manifiestos/skills-lock.json` con SHA256 de cada `habilidades/*\/SKILL.md`.
- * Permite detectar drift silencioso: alguien edita un skill localmente sin
- * commit y nadie lo nota hasta que falla. El lock se regenera en cada
- * `/swl:release` y se valida en `/swl:salud`.
- *
- * Uso:
- *   node scripts/generar-skills-lock.js               # genera y escribe
- *   node scripts/generar-skills-lock.js --check       # compara, falla si hay drift
- *   node scripts/generar-skills-lock.js --json        # imprime resumen JSON
- *
- * Origen: análisis de temp/design.md-main/skills-lock.json (mayo 2026).
- *
- * Zero-dependencies. Compatible Windows (CRLF-safe), Node 18+.
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-const ROOT = path.resolve(__dirname, '..');
-
-// Escritura atómica obligatoria (regla CLAUDE.md). Fallback defensivo.
-let atomicWriteSync;
-try {
-  ({ atomicWriteSync } = require(path.join(ROOT, 'hooks', 'lib', 'atomic-write.js')));
-} catch {
-  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
-}
-const HABILIDADES_DIR = path.join(ROOT, 'habilidades');
-const LOCK_FILE = path.join(ROOT, 'manifiestos', 'skills-lock.json');
-const LOCK_VERSION = 1;
-
-const CHECK = process.argv.includes('--check');
-const JSON_OUT = process.argv.includes('--json');
-
-function sha256(buffer) {
-  return crypto.createHash('sha256').update(buffer).digest('hex');
-}
-
-function leerFrontmatter(contenido) {
-  const m = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
-  if (!m) return {};
-  const fm = {};
-  for (const linea of m[1].split(/\r?\n/)) {
-    const kv = linea.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
-    if (kv) fm[kv[1]] = kv[2].trim();
-  }
-  return fm;
-}
-
-function generarLock() {
-  if (!fs.existsSync(HABILIDADES_DIR)) {
-    console.error(`ERROR: directorio no encontrado: ${HABILIDADES_DIR}`);
-    process.exit(2);
-  }
-
-  const skills = [];
-  const dirs = fs
-    .readdirSync(HABILIDADES_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory())
-    .map((d) => d.name)
-    .sort();
-
-  for (const dir of dirs) {
-    const skillFile = path.join(HABILIDADES_DIR, dir, 'SKILL.md');
-    if (!fs.existsSync(skillFile)) {
-      // Skill sin SKILL.md — anomalía pero no fatal
-      skills.push({
-        nombre: dir,
-        path: `habilidades/${dir}/SKILL.md`,
-        hash: null,
-        bytes: 0,
-        warning: 'skill-md-faltante',
-      });
-      continue;
-    }
-
-    const buffer = fs.readFileSync(skillFile);
-    const contenido = buffer.toString('utf-8');
-    const fm = leerFrontmatter(contenido);
-
-    skills.push({
-      nombre: fm.name || dir,
-      path: `habilidades/${dir}/SKILL.md`,
-      hash: `sha256:${sha256(buffer)}`,
-      bytes: buffer.length,
-      version: fm.version || null,
-    });
-  }
-
-  // Hash agregado del lock completo (excluyendo timestamps)
-  const datosCanonicos = JSON.stringify(
-    skills.map((s) => ({ nombre: s.nombre, hash: s.hash })),
-    null,
-    0
-  );
-  const lockHash = `sha256:${sha256(Buffer.from(datosCanonicos, 'utf-8'))}`;
-
-  return {
-    lockfileVersion: LOCK_VERSION,
-    generatedAt: new Date().toISOString(),
-    skillsCount: skills.length,
-    lockHash,
-    skills,
-  };
-}
-
-function comparar(actual, anterior) {
-  if (!anterior) return { drifted: [], faltantes: actual.skills, nuevos: [] };
-
-  const anteriorMap = new Map(anterior.skills.map((s) => [s.nombre, s]));
-  const actualMap = new Map(actual.skills.map((s) => [s.nombre, s]));
-
-  const drifted = [];
-  const nuevos = [];
-  const faltantes = [];
-
-  for (const s of actual.skills) {
-    const prev = anteriorMap.get(s.nombre);
-    if (!prev) {
-      nuevos.push(s.nombre);
-    } else if (prev.hash !== s.hash) {
-      drifted.push({ nombre: s.nombre, antes: prev.hash, ahora: s.hash });
-    }
-  }
-  for (const s of anterior.skills) {
-    if (!actualMap.has(s.nombre)) {
-      faltantes.push(s.nombre);
-    }
-  }
-
-  return { drifted, faltantes, nuevos };
-}
-
-function main() {
-  const actual = generarLock();
-
-  if (CHECK) {
-    if (!fs.existsSync(LOCK_FILE)) {
-      console.error(`ERROR: ${LOCK_FILE} no existe. Ejecutar sin --check para generarlo.`);
-      process.exit(1);
-    }
-    const anterior = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
-    const diff = comparar(actual, anterior);
-    const total = diff.drifted.length + diff.faltantes.length + diff.nuevos.length;
-
-    if (JSON_OUT) {
-      console.log(JSON.stringify({ ok: total === 0, ...diff }, null, 2));
-    } else if (total === 0) {
-      console.log(`✓ skills-lock OK: ${actual.skillsCount} skills sin drift`);
-    } else {
-      console.log(`✗ skills-lock DRIFT detectado:`);
-      if (diff.drifted.length) {
-        console.log(`  Modificados (${diff.drifted.length}):`);
-        diff.drifted.forEach((d) => console.log(`    - ${d.nombre}`));
-      }
-      if (diff.nuevos.length) {
-        console.log(`  Nuevos (${diff.nuevos.length}):`);
-        diff.nuevos.forEach((n) => console.log(`    - ${n}`));
-      }
-      if (diff.faltantes.length) {
-        console.log(`  Faltantes (${diff.faltantes.length}):`);
-        diff.faltantes.forEach((n) => console.log(`    - ${n}`));
-      }
-      console.log(`\n  Para regenerar: node scripts/generar-skills-lock.js`);
-    }
-    process.exit(total === 0 ? 0 : 1);
-  }
-
-  // Generar
-  atomicWriteSync(LOCK_FILE, JSON.stringify(actual, null, 2) + '\n', 'utf-8');
-  if (JSON_OUT) {
-    console.log(JSON.stringify({ ok: true, file: LOCK_FILE, count: actual.skillsCount }));
-  } else {
-    console.log(`✓ Generado ${LOCK_FILE}`);
-    console.log(`  ${actual.skillsCount} skills, lockHash=${actual.lockHash.slice(0, 23)}...`);
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { generarLock, comparar };
+#!/usr/bin/env node
+/**
+ * generar-skills-lock.js
+ *
+ * Genera `manifiestos/skills-lock.json` con SHA256 de cada `habilidades/*\/SKILL.md`.
+ * Permite detectar drift silencioso: alguien edita un skill localmente sin
+ * commit y nadie lo nota hasta que falla. El lock se regenera en cada
+ * `/swl:release` y se valida en `/swl:salud`.
+ *
+ * Uso:
+ *   node scripts/generar-skills-lock.js               # genera y escribe
+ *   node scripts/generar-skills-lock.js --check       # compara, falla si hay drift
+ *   node scripts/generar-skills-lock.js --json        # imprime resumen JSON
+ *
+ * Origen: análisis de temp/design.md-main/skills-lock.json (mayo 2026).
+ *
+ * Zero-dependencies. Compatible Windows (CRLF-safe), Node 18+.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const ROOT = path.resolve(__dirname, '..');
+
+// Escritura atómica obligatoria (regla CLAUDE.md). Fallback defensivo.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(ROOT, 'hooks', 'lib', 'atomic-write.js')));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
+const HABILIDADES_DIR = path.join(ROOT, 'habilidades');
+const LOCK_FILE = path.join(ROOT, 'manifiestos', 'skills-lock.json');
+const LOCK_VERSION = 1;
+
+const CHECK = process.argv.includes('--check');
+const JSON_OUT = process.argv.includes('--json');
+
+function sha256(buffer) {
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+function leerFrontmatter(contenido) {
+  const m = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!m) return {};
+  const fm = {};
+  for (const linea of m[1].split(/\r?\n/)) {
+    const kv = linea.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+    if (kv) fm[kv[1]] = kv[2].trim();
+  }
+  return fm;
+}
+
+function generarLock() {
+  if (!fs.existsSync(HABILIDADES_DIR)) {
+    console.error(`ERROR: directorio no encontrado: ${HABILIDADES_DIR}`);
+    process.exit(2);
+  }
+
+  const skills = [];
+  const dirs = fs
+    .readdirSync(HABILIDADES_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .sort();
+
+  for (const dir of dirs) {
+    const skillFile = path.join(HABILIDADES_DIR, dir, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) {
+      // Skill sin SKILL.md — anomalía pero no fatal
+      skills.push({
+        nombre: dir,
+        path: `habilidades/${dir}/SKILL.md`,
+        hash: null,
+        bytes: 0,
+        warning: 'skill-md-faltante',
+      });
+      continue;
+    }
+
+    const buffer = fs.readFileSync(skillFile);
+    const contenido = buffer.toString('utf-8');
+    const fm = leerFrontmatter(contenido);
+
+    skills.push({
+      nombre: fm.name || dir,
+      path: `habilidades/${dir}/SKILL.md`,
+      hash: `sha256:${sha256(buffer)}`,
+      bytes: buffer.length,
+      version: fm.version || null,
+    });
+  }
+
+  // Hash agregado del lock completo (excluyendo timestamps)
+  const datosCanonicos = JSON.stringify(
+    skills.map((s) => ({ nombre: s.nombre, hash: s.hash })),
+    null,
+    0
+  );
+  const lockHash = `sha256:${sha256(Buffer.from(datosCanonicos, 'utf-8'))}`;
+
+  return {
+    lockfileVersion: LOCK_VERSION,
+    generatedAt: new Date().toISOString(),
+    skillsCount: skills.length,
+    lockHash,
+    skills,
+  };
+}
+
+function comparar(actual, anterior) {
+  if (!anterior) return { drifted: [], faltantes: actual.skills, nuevos: [] };
+
+  const anteriorMap = new Map(anterior.skills.map((s) => [s.nombre, s]));
+  const actualMap = new Map(actual.skills.map((s) => [s.nombre, s]));
+
+  const drifted = [];
+  const nuevos = [];
+  const faltantes = [];
+
+  for (const s of actual.skills) {
+    const prev = anteriorMap.get(s.nombre);
+    if (!prev) {
+      nuevos.push(s.nombre);
+    } else if (prev.hash !== s.hash) {
+      drifted.push({ nombre: s.nombre, antes: prev.hash, ahora: s.hash });
+    }
+  }
+  for (const s of anterior.skills) {
+    if (!actualMap.has(s.nombre)) {
+      faltantes.push(s.nombre);
+    }
+  }
+
+  return { drifted, faltantes, nuevos };
+}
+
+function main() {
+  const actual = generarLock();
+
+  if (CHECK) {
+    if (!fs.existsSync(LOCK_FILE)) {
+      console.error(`ERROR: ${LOCK_FILE} no existe. Ejecutar sin --check para generarlo.`);
+      process.exit(1);
+    }
+    const anterior = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+    const diff = comparar(actual, anterior);
+    const total = diff.drifted.length + diff.faltantes.length + diff.nuevos.length;
+
+    if (JSON_OUT) {
+      console.log(JSON.stringify({ ok: total === 0, ...diff }, null, 2));
+    } else if (total === 0) {
+      console.log(`✓ skills-lock OK: ${actual.skillsCount} skills sin drift`);
+    } else {
+      console.log(`✗ skills-lock DRIFT detectado:`);
+      if (diff.drifted.length) {
+        console.log(`  Modificados (${diff.drifted.length}):`);
+        diff.drifted.forEach((d) => console.log(`    - ${d.nombre}`));
+      }
+      if (diff.nuevos.length) {
+        console.log(`  Nuevos (${diff.nuevos.length}):`);
+        diff.nuevos.forEach((n) => console.log(`    - ${n}`));
+      }
+      if (diff.faltantes.length) {
+        console.log(`  Faltantes (${diff.faltantes.length}):`);
+        diff.faltantes.forEach((n) => console.log(`    - ${n}`));
+      }
+      console.log(`\n  Para regenerar: node scripts/generar-skills-lock.js`);
+    }
+    process.exit(total === 0 ? 0 : 1);
+  }
+
+  // Generar
+  atomicWriteSync(LOCK_FILE, JSON.stringify(actual, null, 2) + '\n', 'utf-8');
+  if (JSON_OUT) {
+    console.log(JSON.stringify({ ok: true, file: LOCK_FILE, count: actual.skillsCount }));
+  } else {
+    console.log(`✓ Generado ${LOCK_FILE}`);
+    console.log(`  ${actual.skillsCount} skills, lockHash=${actual.lockHash.slice(0, 23)}...`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { generarLock, comparar, main };

package/scripts/inbox-tmux-inject.js

@@ -159,3 +159,9 @@ function main() {
 }
 
 if (require.main === module) main();
+
+// Exporta main para que el wrapper del bin CLI
+// (`scripts/cli/inbox-tmux-inject.js`) pueda invocarla sin depender del
+// guard `require.main === module`, que solo es true cuando el script se
+// ejecuta como punto de entrada directo (no cuando es require()d).
+module.exports = { main };

package/scripts/lib/skill-discovery.js

@@ -187,13 +187,15 @@ function buscar(cwd, query) {
 // Exports
 // ---------------------------------------------------------------------------
 
-module.exports = { descubrir, buscar, cargarIndice, escanear };
-
 // ---------------------------------------------------------------------------
 // CLI directo
 // ---------------------------------------------------------------------------
 
-if (require.main === module) {
+// Extraído a función nombrada para que el wrapper del bin CLI
+// (`scripts/cli/skill-discovery.js`) pueda invocarla sin depender del guard
+// `require.main === module`, que solo se cumple cuando el script se ejecuta
+// como punto de entrada directo (no cuando es require()d desde otro módulo).
+function main() {
   const cwd  = process.cwd();
   const args = process.argv.slice(2);
 
@@ -232,3 +234,9 @@ if (require.main === module) {
     process.stdout.write(`Uso: Skill("nombre-de-habilidad")\n\n`);
   }
 }
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { descubrir, buscar, cargarIndice, escanear, main };

package/scripts/verificar-evolucion.js

@@ -286,4 +286,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { verificarArchivo, extraerFrontmatter, leerCampo, obtenerVersionEnHEAD };
+module.exports = { verificarArchivo, extraerFrontmatter, leerCampo, obtenerVersionEnHEAD, main };