@saulwade/swl-ses 1.3.1 → 1.3.3

package/scripts/cli/audit-claudemd.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * Wrapper CLI para el subcomando `swl-ses audit-claudemd`.
+ *
+ * Por qué existe este wrapper:
+ *   `scripts/auditar-claudemd.js` está diseñado como CLI standalone que lee
+ *   `process.argv`. El dispatcher de `bin/swl-ses.js`, en cambio, espera un
+ *   módulo que exporta una función única `fn(opciones)` con las flags ya
+ *   parseadas. Este wrapper traduce entre ambos contratos.
+ *
+ * Mapeo de opciones del bin → flags del script:
+ *   --json    → '--json'
+ *   --strict  → '--strict'
+ *   _args[0]  → primer argumento posicional (ruta opcional al CLAUDE.md)
+ *
+ * Salida: el script standalone hace `process.exit(0|1)` por sí mismo, así que
+ * este wrapper no necesita retornar nada — main() se encarga.
+ */
+
+const { main } = require('../auditar-claudemd.js');
+
+function auditClaudemd(opciones) {
+  const args = [];
+  if (opciones && opciones.json) args.push('--json');
+  if (opciones && opciones.strict) args.push('--strict');
+  if (opciones && Array.isArray(opciones._args) && opciones._args[0]) {
+    args.push(opciones._args[0]);
+  }
+
+  // El script lee process.argv.slice(2). Sustituir argv durante la ejecución.
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'auditar-claudemd.js', ...args];
+  try {
+    main();
+  } finally {
+    // main() típicamente llama process.exit; este finally es defensivo por
+    // si en el futuro main() deja de salir explícitamente.
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = auditClaudemd;

package/scripts/cli/audit-coverage-frameworks.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses audit-coverage-frameworks`.
+ *
+ * Audita la cobertura de frameworks de seguridad (NIST CSF, NIST AI RMF,
+ * MITRE ATT&CK, ATLAS, D3FEND) en los skills SWL del dominio seguridad.
+ * El script standalone NO exporta main, ejecuta en top-level. Wrapper
+ * hace require() directo con argv manipulado.
+ *
+ * Flags soportadas:
+ *   --resumen           → output resumen compacto
+ *   --framework=<id>    → analizar solo un framework específico
+ *   --save              → persiste el resultado en archivo
+ */
+
+const path = require('path');
+
+function auditCoverageFrameworks(opciones) {
+  const args = [];
+  if (opciones && opciones.resumen) args.push('--resumen');
+  if (opciones && opciones.framework) args.push(`--framework=${opciones.framework}`);
+  if (opciones && opciones.save) args.push('--save');
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'auditar-cobertura-frameworks.js', ...args];
+  try {
+    const ruta = path.resolve(__dirname, '..', 'auditar-cobertura-frameworks.js');
+    delete require.cache[ruta];
+    require(ruta);
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = auditCoverageFrameworks;

package/scripts/cli/bootstrap-instincts.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses bootstrap-instincts`.
+ *
+ * Pobla `instintos/proyecto.yaml` desde `APRENDIZAJES.md` del proyecto actual.
+ * Adapta opciones del bin al main() de `scripts/bootstrap-instintos.js`.
+ *
+ * Flags soportadas (las que el script standalone acepta):
+ *   --write     → '--write' (persiste en instintos/proyecto.yaml; default es dry-run)
+ *   --dry-run   → '--dry-run' (explícito, redundante con default)
+ *   --force     → '--force' (sobreescribe instintos existentes)
+ *   --json      → '--json' (output JSON estructurado)
+ */
+
+const { main } = require('../bootstrap-instintos.js');
+
+function bootstrapInstincts(opciones) {
+  const args = [];
+  if (opciones && opciones.write) args.push('--write');
+  // Defensa contra parser inconsistente: aceptar ambas formas.
+  if (opciones && (opciones['dry-run'] || opciones.dry_run)) args.push('--dry-run');
+  if (opciones && opciones.force) args.push('--force');
+  if (opciones && opciones.json) args.push('--json');
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'bootstrap-instintos.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = bootstrapInstincts;

package/scripts/cli/configure-branch-protection.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses configure-branch-protection`.
+ *
+ * El script standalone `scripts/configurar-branch-protection.js` ejecuta su
+ * lógica en top-level (no tiene main() exportable). Para reusarlo, este
+ * wrapper manipula `process.argv` y hace `require()` directo — al cargarse
+ * el módulo, su código top-level se ejecuta con los argumentos correctos.
+ *
+ * Flags soportadas:
+ *   --dry-run    → '--dry-run' (no aplica cambios, solo muestra)
+ *   _args[0+]    → argumentos posicionales (repo, branch)
+ *
+ * Importante: el `require()` no se cachea entre invocaciones distintas del
+ * CLI porque cada llamada desde shell es un proceso Node fresco. Dentro del
+ * mismo proceso, solo se invoca una vez por design del CLI dispatcher.
+ */
+
+const path = require('path');
+
+function configureBranchProtection(opciones) {
+  const args = [];
+  // Defensa contra parser inconsistente: aceptar ambas formas.
+  if (opciones && (opciones['dry-run'] || opciones.dry_run)) args.push('--dry-run');
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'configurar-branch-protection.js', ...args];
+  try {
+    // Limpiar caché para garantizar re-ejecución si el módulo ya fue cargado.
+    const ruta = path.resolve(__dirname, '..', 'configurar-branch-protection.js');
+    delete require.cache[ruta];
+    require(ruta);
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = configureBranchProtection;

package/scripts/cli/generate-skills-lock.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses generate-skills-lock`.
+ *
+ * Regenera `manifiestos/skills-lock.json` con el SHA256 de cada SKILL.md.
+ * El lock permite detectar drift silencioso de skills entre releases.
+ *
+ * Flags soportadas:
+ *   --check   → no escribe, compara contra el lock actual y exit 1 si difiere
+ */
+
+const { main } = require('../generar-skills-lock.js');
+
+function generateSkillsLock(opciones) {
+  const args = [];
+  if (opciones && opciones.check) args.push('--check');
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'generar-skills-lock.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = generateSkillsLock;

package/scripts/cli/inbox-tmux-inject.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses inbox-tmux-inject`.
+ *
+ * Servicio opt-in Linux/macOS que poll-ea `.planning/inbox/` y reinyecta
+ * comandos a una sesión tmux activa de Claude Code. NO funcional en
+ * Windows nativo (requiere tmux).
+ *
+ * El script standalone tiene un guard `if (require.main === module) main();`
+ * que NO se cumple cuando require()d desde el bin dispatcher. Por eso este
+ * wrapper invoca `main()` exportado explícitamente en vez de hacer require()
+ * directo del script.
+ *
+ * Flags soportadas:
+ *   --session=<nombre>  → sesión tmux destino (default 'claude')
+ *   --poll=<segundos>   → intervalo de polling (default 3)
+ *   --dry-run           → no inyecta, solo reporta
+ */
+
+const { main } = require('../inbox-tmux-inject.js');
+
+function inboxTmuxInject(opciones) {
+  const args = [];
+
+  // El parser del bin acepta dashes y underscores (ambas formas).
+  if (opciones && opciones.session) {
+    args.push('--session', String(opciones.session));
+  }
+  if (opciones && opciones.poll !== undefined) {
+    args.push('--poll', String(opciones.poll));
+  }
+  if (opciones && (opciones['dry-run'] || opciones.dry_run)) {
+    args.push('--dry-run');
+  }
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'inbox-tmux-inject.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = inboxTmuxInject;

package/scripts/cli/reflect-skills.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses reflect-skills`.
+ *
+ * `scripts/reflect-skills.js` exporta `main` y funciones puras
+ * (extraerPrompts, clusterizarPrompts, etc.). Este wrapper adapta el
+ * contrato del bin dispatcher al main() que lee process.argv.
+ *
+ * Flags soportadas:
+ *   --ventana=<N>   → ventana de días a analizar (default 30)
+ *   --umbral=<N>    → umbral mínimo de prompts por cluster (default 3)
+ *   --json          → output JSON estructurado
+ *   --proyecto      → analizar solo proyecto actual
+ *   --globales      → analizar solo skills globales
+ */
+
+const { main } = require('../reflect-skills.js');
+
+function reflectSkills(opciones) {
+  const args = [];
+  if (opciones && opciones.ventana !== undefined) args.push(`--ventana=${opciones.ventana}`);
+  if (opciones && opciones.umbral !== undefined) args.push(`--umbral=${opciones.umbral}`);
+  if (opciones && opciones.json) args.push('--json');
+  if (opciones && opciones.proyecto) args.push('--proyecto');
+  if (opciones && opciones.globales) args.push('--globales');
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'reflect-skills.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = reflectSkills;

package/scripts/cli/run-skill-evals.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses run-skill-evals`.
+ *
+ * El script standalone `scripts/run-skill-evals.js` ejecuta su lógica en
+ * top-level. Wrapper hace `require()` directo con `process.argv` manipulado.
+ *
+ * Flags y argumentos soportados:
+ *   primer posicional      → nombre del skill
+ *   --list                 → listar evals del skill
+ *   --json                 → output JSON
+ *   --record-baseline      → registrar score baseline
+ *   --record-after         → registrar score post-cambio
+ *   --score=<N>            → score numérico (acompaña --record-*)
+ *   --hypothesis=<texto>   → hipótesis de la mutación
+ *   --invariantes-ok       → marcar invariantes como OK
+ */
+
+const path = require('path');
+
+function runSkillEvals(opciones) {
+  const args = [];
+
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+  if (opciones && opciones.list) args.push('--list');
+  if (opciones && opciones.json) args.push('--json');
+  if (opciones && opciones['record-baseline']) args.push('--record-baseline');
+  if (opciones && opciones['record-after']) args.push('--record-after');
+  if (opciones && opciones.score !== undefined) args.push(`--score=${opciones.score}`);
+  if (opciones && opciones.hypothesis) args.push(`--hypothesis=${opciones.hypothesis}`);
+  if (opciones && opciones['invariantes-ok']) args.push('--invariantes-ok');
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'run-skill-evals.js', ...args];
+  try {
+    const ruta = path.resolve(__dirname, '..', 'run-skill-evals.js');
+    delete require.cache[ruta];
+    require(ruta);
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = runSkillEvals;

package/scripts/cli/skill-discovery.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses skill-discovery`.
+ *
+ * Descubre y busca skills SWL por nombre, descripción o palabras clave.
+ * El script vive en `scripts/lib/skill-discovery.js` (no en `scripts/`).
+ *
+ * El script standalone tiene un guard `if (require.main === module) main();`
+ * que NO se cumple cuando require()d desde el bin dispatcher. Por eso este
+ * wrapper invoca `main()` exportado explícitamente en vez de hacer require()
+ * directo del script.
+ *
+ * Argumentos y flags:
+ *   primer posicional   → query de búsqueda (opcional; sin query lista todos)
+ *   --rebuild           → fuerza reconstrucción del índice (ignora caché)
+ */
+
+const { main } = require('../lib/skill-discovery.js');
+
+function skillDiscovery(opciones) {
+  const args = [];
+
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+  if (opciones && opciones.rebuild) args.push('--rebuild');
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'skill-discovery.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = skillDiscovery;

package/scripts/cli/verify-evolution.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/**
+ * Wrapper CLI para `swl-ses verify-evolution`.
+ *
+ * Adapta el contrato del bin (recibe objeto opciones con flags ya parseadas)
+ * al main() de `scripts/verificar-evolucion.js` que lee process.argv.
+ *
+ * Mapeo de opciones del bin → flags del script:
+ *   --changed      → '--changed'
+ *   --since=<rev>  → '--since=<rev>'
+ *   --json         → '--json'
+ *   _args[0+]      → archivos posicionales (paths a verificar)
+ */
+
+const { main } = require('../verificar-evolucion.js');
+
+function verifyEvolution(opciones) {
+  const args = [];
+  if (opciones && opciones.changed) args.push('--changed');
+  if (opciones && opciones.since) args.push(`--since=${opciones.since}`);
+  if (opciones && opciones.json) args.push('--json');
+  if (opciones && Array.isArray(opciones._args)) {
+    args.push(...opciones._args);
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'verificar-evolucion.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = verifyEvolution;