@saulwade/swl-ses 1.0.0

package/scripts/lib/selector-interactivo.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const readline = require('readline');
+
+/**
+ * Muestra un selector interactivo de checkboxes en la terminal.
+ * El usuario navega con flechas, selecciona con espacio, confirma con enter.
+ *
+ * @param {string} titulo - Título del selector
+ * @param {Array<{nombre: string, descripcion?: string}>} items - Items disponibles
+ * @param {object} opciones
+ * @param {boolean} opciones.todosSeleccionados - Si true, todos empiezan seleccionados
+ * @returns {Promise<string[]>} - Nombres de los items seleccionados
+ */
+function selectorCheckbox(titulo, items, opciones = {}) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) {
+      // Sin terminal interactiva: seleccionar todos
+      resolve(items.map(i => i.nombre));
+      return;
+    }
+
+    const seleccionados = new Set(
+      opciones.todosSeleccionados ? items.map(i => i.nombre) : []
+    );
+    let cursor = 0;
+    const maxVisible = Math.min(items.length, process.stdout.rows - 6 || 20);
+    let scrollOffset = 0;
+
+    function renderizar() {
+      // Limpiar líneas previas
+      const lineasTotal = maxVisible + 3;
+      process.stdout.write(`\x1b[${lineasTotal}A\x1b[0J`);
+      dibujar();
+    }
+
+    function dibujar() {
+      const lineas = [];
+      lineas.push(`  \x1b[1m${titulo}\x1b[0m \x1b[2m(espacio = toggle, enter = confirmar, a = todos)\x1b[0m`);
+      lineas.push('');
+
+      // Ajustar scroll
+      if (cursor < scrollOffset) scrollOffset = cursor;
+      if (cursor >= scrollOffset + maxVisible) scrollOffset = cursor - maxVisible + 1;
+
+      for (let i = scrollOffset; i < Math.min(items.length, scrollOffset + maxVisible); i++) {
+        const item = items[i];
+        const esCursor = i === cursor;
+        const marcado = seleccionados.has(item.nombre);
+
+        const prefijo = esCursor ? '\x1b[36m❯\x1b[0m' : ' ';
+        const checkbox = marcado ? '\x1b[32m◉\x1b[0m' : '○';
+        const nombre = esCursor ? `\x1b[1m${item.nombre}\x1b[0m` : item.nombre;
+
+        lineas.push(`  ${prefijo} ${checkbox} ${nombre}`);
+      }
+
+      if (items.length > maxVisible) {
+        const porcentaje = Math.round(((scrollOffset + maxVisible) / items.length) * 100);
+        lineas.push(`  \x1b[2m── ${porcentaje}% ──\x1b[0m`);
+      } else {
+        lineas.push('');
+      }
+
+      process.stdout.write(lineas.join('\n') + '\n');
+    }
+
+    // Dibujo inicial (escribir líneas en blanco primero para tener espacio)
+    const lineasTotal = maxVisible + 3;
+    process.stdout.write('\n'.repeat(lineasTotal));
+    process.stdout.write(`\x1b[${lineasTotal}A`);
+    dibujar();
+
+    // Manejar input
+    readline.emitKeypressEvents(process.stdin);
+    const modoAnterior = process.stdin.isRaw;
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    function limpiar() {
+      process.stdin.setRawMode(modoAnterior || false);
+      process.stdin.removeListener('keypress', onKeypress);
+      process.stdin.pause();
+    }
+
+    function onKeypress(str, key) {
+      if (!key) return;
+
+      if (key.name === 'up' || (key.name === 'k')) {
+        cursor = cursor > 0 ? cursor - 1 : items.length - 1;
+        renderizar();
+      } else if (key.name === 'down' || (key.name === 'j')) {
+        cursor = cursor < items.length - 1 ? cursor + 1 : 0;
+        renderizar();
+      } else if (key.name === 'space') {
+        const nombre = items[cursor].nombre;
+        if (seleccionados.has(nombre)) {
+          seleccionados.delete(nombre);
+        } else {
+          seleccionados.add(nombre);
+        }
+        renderizar();
+      } else if (str === 'a' || str === 'A') {
+        // Toggle all
+        if (seleccionados.size === items.length) {
+          seleccionados.clear();
+        } else {
+          items.forEach(i => seleccionados.add(i.nombre));
+        }
+        renderizar();
+      } else if (key.name === 'return') {
+        limpiar();
+        resolve(Array.from(seleccionados));
+      } else if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        limpiar();
+        resolve([]);
+      }
+    }
+
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+/**
+ * Muestra el banner ASCII del instalador de skills
+ */
+function mostrarBanner() {
+  const banner = `
+\x1b[36m\x1b[1m  ╔═╗╦╔═╦╦  ╦  ╔═╗
+  ╚═╗╠╩╗║║  ║  ╚═╗
+  ╚═╝╩ ╩╩╩═╝╩═╝╚═╝\x1b[0m`;
+  console.log(banner);
+  console.log('');
+}
+
+/**
+ * Muestra información de la fuente antes de la selección
+ */
+function mostrarInfoFuente(fuente, totalSkills) {
+  console.log(`  \x1b[2mSource:\x1b[0m ${fuente}`);
+  console.log('');
+  console.log('  \x1b[32mRepository cloned\x1b[0m');
+  console.log('');
+  console.log(`  \x1b[1mFound:\x1b[0m ${totalSkills} skills`);
+  console.log('');
+}
+
+module.exports = {
+  selectorCheckbox,
+  mostrarBanner,
+  mostrarInfoFuente,
+};

package/scripts/lib/semantic-search.js

@@ -0,0 +1,242 @@
+'use strict';
+
+/**
+ * semantic-search.js
+ *
+ * Búsqueda híbrida con fallback automático:
+ *   - Default: Jaccard similarity sobre tokens normalizados (zero-deps).
+ *   - Opt-in: embeddings con @xenova/transformers (vía SWL_SEMANTIC_BACKEND=xenova).
+ *
+ * Patrón adaptado de `temp/cass_memory_system-main/src/semantic.ts`. Diferencias:
+ *   - Carga lazy de Xenova (no requiere instalación si no se usa).
+ *   - API uniforme: el caller no sabe qué backend está activo.
+ *   - Tokenización compatible con español (acentos preservados, stopwords es-MX).
+ *
+ * Cuándo usar:
+ *   - Buscar skills similares por significado, no solo keywords (150 skills).
+ *   - Encontrar instintos relacionados a un patrón observado.
+ *   - Detectar duplicados semánticos en APRENDIZAJES.md.
+ *
+ * API:
+ *   - jaccardSimilarity(a, b)              → [0, 1]
+ *   - cosineSimilarity(a, b)               → [-1, 1] (vectores numéricos)
+ *   - tokenize(text)                       → array de tokens
+ *   - semanticRank(query, items, opts)     → items rankeados por similitud
+ *
+ * Backend: el módulo NO requiere Xenova. Si SWL_SEMANTIC_BACKEND=xenova y
+ * @xenova/transformers está instalado, se usa para embeddings. Si no, Jaccard.
+ *
+ * @module scripts/lib/semantic-search
+ */
+
+// ── stopwords es-MX ───────────────────────────────────────────────────────────
+
+const STOPWORDS = new Set([
+  'a', 'al', 'algo', 'algunas', 'algunos', 'ante', 'antes', 'aunque',
+  'cada', 'cierta', 'ciertas', 'cierto', 'ciertos', 'como', 'con', 'contra',
+  'cual', 'cuando', 'de', 'del', 'desde', 'donde', 'durante',
+  'e', 'el', 'ella', 'ellas', 'ellos', 'en', 'entre', 'era', 'erais', 'eran',
+  'eras', 'eres', 'es', 'esa', 'esas', 'ese', 'eso', 'esos', 'esta', 'estaba',
+  'estaban', 'estado', 'estamos', 'estan', 'están', 'estar', 'estas', 'este',
+  'esto', 'estos', 'estoy', 'fue', 'fuera', 'fueron', 'fui', 'ha', 'habia',
+  'había', 'han', 'hasta', 'hay', 'haya', 'la', 'las', 'le', 'les', 'lo',
+  'los', 'me', 'mi', 'mis', 'mucho', 'muchos', 'muy', 'nada', 'ni', 'no',
+  'nos', 'nosotros', 'nuestra', 'nuestras', 'nuestro', 'nuestros', 'o', 'os',
+  'otra', 'otras', 'otro', 'otros', 'para', 'pero', 'poco', 'por', 'porque',
+  'que', 'quien', 'quienes', 'qué', 'se', 'sea', 'sean', 'ser', 'si', 'sí',
+  'sido', 'siendo', 'sin', 'sobre', 'soy', 'su', 'sus', 'también', 'tan',
+  'tanto', 'te', 'tener', 'ti', 'tiene', 'tienen', 'todo', 'todos', 'tu',
+  'tus', 'un', 'una', 'unas', 'uno', 'unos', 'usted', 'ustedes', 'va', 'vais',
+  'van', 'vas', 'ver', 'y', 'ya', 'yo',
+]);
+
+// ── tokenización ──────────────────────────────────────────────────────────────
+
+/**
+ * Tokeniza texto en español de México. Pasos:
+ *   1. lowercase
+ *   2. eliminar puntuación
+ *   3. dividir en palabras
+ *   4. eliminar stopwords
+ *   5. eliminar tokens muy cortos (<2 chars)
+ *
+ * Preserva acentos (cá vs ca son distintos). No hace stemming.
+ *
+ * @param {string} texto
+ * @returns {string[]} tokens
+ */
+function tokenize(texto) {
+  if (!texto || typeof texto !== 'string') return [];
+  return texto
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')   // letras unicode + números
+    .split(/\s+/)
+    .filter(t => t.length >= 2 && !STOPWORDS.has(t));
+}
+
+// ── Jaccard ───────────────────────────────────────────────────────────────────
+
+/**
+ * Jaccard similarity sobre conjuntos de tokens.
+ * jaccard(A, B) = |A ∩ B| / |A ∪ B|
+ *
+ * Ambos textos vacíos → 0 (no hay similitud, no hay info).
+ * Un texto vacío + uno con tokens → 0.
+ *
+ * @param {string} textA
+ * @param {string} textB
+ * @returns {number} en [0, 1]
+ */
+function jaccardSimilarity(textA, textB) {
+  const a = new Set(tokenize(textA));
+  const b = new Set(tokenize(textB));
+  if (a.size === 0 && b.size === 0) return 0;
+  if (a.size === 0 || b.size === 0) return 0;
+
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter++;
+  const union = a.size + b.size - inter;
+  return inter / union;
+}
+
+// ── Cosine (para embeddings) ──────────────────────────────────────────────────
+
+/**
+ * Cosine similarity entre dos vectores numéricos.
+ * cos(A, B) = (A · B) / (||A|| × ||B||)
+ *
+ * @param {number[]} vecA
+ * @param {number[]} vecB
+ * @returns {number} en [-1, 1]
+ */
+function cosineSimilarity(vecA, vecB) {
+  if (!Array.isArray(vecA) || !Array.isArray(vecB)) return 0;
+  if (vecA.length !== vecB.length || vecA.length === 0) return 0;
+
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < vecA.length; i++) {
+    const a = vecA[i] || 0;
+    const b = vecB[i] || 0;
+    dot += a * b;
+    normA += a * a;
+    normB += b * b;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// ── backend de embeddings (Xenova lazy) ───────────────────────────────────────
+
+/**
+ * Estado lazy del backend Xenova. Se carga la primera vez que se invoca
+ * embeddingsBackend() y NO falla si no está instalado.
+ */
+let _xenovaPipeline = null;
+let _xenovaTried = false;
+
+async function tryLoadXenova() {
+  if (_xenovaPipeline || _xenovaTried) return _xenovaPipeline;
+  _xenovaTried = true;
+  try {
+    // Carga dinámica para evitar require al inicio
+    const transformers = require('@xenova/transformers');
+    const { pipeline } = transformers;
+    _xenovaPipeline = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+    return _xenovaPipeline;
+  } catch (_) {
+    // No instalado o error al cargar: silencioso. Caller usará fallback.
+    return null;
+  }
+}
+
+/**
+ * Detecta el backend activo según SWL_SEMANTIC_BACKEND.
+ * Sin variable o valor != 'xenova' → 'jaccard'.
+ */
+function activeBackend() {
+  const env = (process.env.SWL_SEMANTIC_BACKEND || '').toLowerCase().trim();
+  return env === 'xenova' ? 'xenova' : 'jaccard';
+}
+
+/**
+ * Embebe un texto en un vector. Solo disponible si Xenova está activo.
+ * Retorna null si el backend no es xenova o no se pudo cargar.
+ *
+ * @param {string} texto
+ * @returns {Promise<number[]|null>}
+ */
+async function embed(texto) {
+  if (activeBackend() !== 'xenova') return null;
+  const pipe = await tryLoadXenova();
+  if (!pipe) return null;
+  try {
+    const out = await pipe(texto, { pooling: 'mean', normalize: true });
+    return Array.from(out.data);
+  } catch (_) {
+    return null;
+  }
+}
+
+// ── ranking ──────────────────────────────────────────────────────────────────
+
+/**
+ * Rankea items por similitud con la query.
+ *
+ * @param {string} query
+ * @param {Array<{id: string, text: string, embedding?: number[]}>} items
+ * @param {object} [opts]
+ * @param {number} [opts.threshold=0]  - filtra resultados con score < threshold
+ * @param {number} [opts.limit=10]     - limita resultados
+ * @returns {Promise<Array<{id, text, score, backend}>>}
+ */
+async function semanticRank(query, items, opts = {}) {
+  const { threshold = 0, limit = 10 } = opts;
+  if (!query || !Array.isArray(items)) return [];
+
+  const backend = activeBackend();
+  let results;
+
+  if (backend === 'xenova') {
+    const queryEmb = await embed(query);
+    if (queryEmb) {
+      results = await Promise.all(items.map(async (item) => {
+        let itemEmb = item.embedding;
+        if (!itemEmb) itemEmb = await embed(item.text || '');
+        const score = (queryEmb && itemEmb) ? cosineSimilarity(queryEmb, itemEmb) : 0;
+        return { id: item.id, text: item.text, score, backend: 'xenova' };
+      }));
+    } else {
+      // Backend declarado pero no disponible → fallback transparente
+      results = items.map(item => ({
+        id: item.id,
+        text: item.text,
+        score: jaccardSimilarity(query, item.text || ''),
+        backend: 'jaccard-fallback',
+      }));
+    }
+  } else {
+    results = items.map(item => ({
+      id: item.id,
+      text: item.text,
+      score: jaccardSimilarity(query, item.text || ''),
+      backend: 'jaccard',
+    }));
+  }
+
+  return results
+    .filter(r => r.score >= threshold)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+
+module.exports = {
+  tokenize,
+  jaccardSimilarity,
+  cosineSimilarity,
+  embed,
+  semanticRank,
+  activeBackend,
+  STOPWORDS,
+};

package/scripts/lib/skill-discovery.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * skill-discovery.js — Auto-discovery de habilidades SWL.
+ *
+ * Scannea habilidades/<nombre>/SKILL.md y extrae metadata del frontmatter YAML.
+ * Genera un índice en .planning/skill-index.json para:
+ *   - Auto-complete en prompts del orquestador
+ *   - Búsqueda rápida por nombre o descripción
+ *   - Validación de skills disponibles antes de invocar Skill("nombre")
+ *
+ * API:
+ *   descubrir(cwd)      → escanea habilidades/, escribe skill-index.json, retorna índice
+ *   buscar(cwd, query)  → busca en el índice por nombre o descripción (fuzzy)
+ *   cargarIndice(cwd)   → lee skill-index.json existente (sin re-escanear)
+ *   escanear(cwd)       → retorna array de skills sin escribir al disco
+ *
+ * Uso CLI:
+ *   node scripts/lib/skill-discovery.js              → genera índice, imprime total
+ *   node scripts/lib/skill-discovery.js <query>      → busca y muestra resultados
+ *   node scripts/lib/skill-discovery.js --rebuild    → fuerza re-escaneo completo
+ *
+ * @module scripts/lib/skill-discovery
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// Usar atomic-write del proyecto para consistencia
+const atomicWritePath = path.join(__dirname, '..', '..', 'hooks', 'lib', 'atomic-write.js');
+const { atomicWriteJSON } = require(atomicWritePath);
+
+const HABILIDADES_DIR = 'habilidades';
+const SKILL_INDEX     = path.join('.planning', 'skill-index.json');
+
+// ---------------------------------------------------------------------------
+// Parser de frontmatter YAML
+// ---------------------------------------------------------------------------
+
+/**
+ * Parsea el bloque YAML frontmatter de un archivo Markdown.
+ * Solo extrae los campos: name, description, version.
+ * No usa dependencias externas — parseo manual de YAML simple.
+ *
+ * @param {string} contenido - Contenido completo del archivo .md
+ * @returns {{ name?: string, description?: string, version?: string }}
+ */
+function parsearFrontmatter(contenido) {
+  const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+
+  const meta   = {};
+  const lineas = match[1].split('\n');
+
+  for (const linea of lineas) {
+    const idx = linea.indexOf(':');
+    if (idx < 0) continue;
+
+    const clave = linea.slice(0, idx).trim();
+    if (!['name', 'description', 'version'].includes(clave)) continue;
+
+    // Eliminar comillas opcionales del valor
+    const valor = linea.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+    meta[clave] = valor;
+  }
+
+  return meta;
+}
+
+// ---------------------------------------------------------------------------
+// Escaneo de habilidades
+// ---------------------------------------------------------------------------
+
+/**
+ * Escanea el directorio habilidades/ y extrae metadata de cada SKILL.md.
+ * No escribe al disco — solo retorna el array de skills.
+ *
+ * @param {string} cwd - Directorio raíz del proyecto.
+ * @returns {object[]} Array de objetos de skill ordenados por ID.
+ */
+function escanear(cwd) {
+  const habilidadesPath = path.join(cwd, HABILIDADES_DIR);
+  if (!fs.existsSync(habilidadesPath)) return [];
+
+  const skills = [];
+
+  for (const entry of fs.readdirSync(habilidadesPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+
+    const skillMdPath = path.join(habilidadesPath, entry.name, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) continue;
+
+    try {
+      const contenido = fs.readFileSync(skillMdPath, 'utf8');
+      const meta      = parsearFrontmatter(contenido);
+
+      skills.push({
+        id:          entry.name,
+        nombre:      meta.name        || entry.name,
+        descripcion: meta.description || '(sin descripción)',
+        version:     meta.version     || '1.0.0',
+        ruta:        path.join(HABILIDADES_DIR, entry.name),
+        actualizadoEn: (() => {
+          try {
+            return fs.statSync(skillMdPath).mtime.toISOString();
+          } catch (_) {
+            return null;
+          }
+        })(),
+      });
+    } catch (_) {
+      // Saltar skills con errores de lectura
+    }
+  }
+
+  return skills.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Descubre todas las habilidades y escribe el índice en .planning/skill-index.json.
+ *
+ * @param {string} cwd - Directorio raíz del proyecto.
+ * @returns {{ skills: object[], generadoEn: string, version: number, total: number }}
+ */
+function descubrir(cwd) {
+  const skills = escanear(cwd);
+
+  const indice = {
+    generadoEn: new Date().toISOString(),
+    version:    1,
+    total:      skills.length,
+    skills,
+  };
+
+  // Asegurar que .planning/ existe
+  const planDir = path.join(cwd, '.planning');
+  if (!fs.existsSync(planDir)) {
+    fs.mkdirSync(planDir, { recursive: true });
+  }
+
+  atomicWriteJSON(path.join(cwd, SKILL_INDEX), indice);
+  return indice;
+}
+
+/**
+ * Carga el índice existente sin re-escanear.
+ *
+ * @param {string} cwd
+ * @returns {{ skills: object[], generadoEn: string, total: number }|null} null si no existe.
+ */
+function cargarIndice(cwd) {
+  const indexPath = path.join(cwd, SKILL_INDEX);
+  try {
+    return JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Busca skills por nombre, ID o descripción.
+ * Usa el índice existente; si no existe lo genera.
+ *
+ * @param {string} cwd
+ * @param {string} query - Término de búsqueda (case-insensitive).
+ * @returns {object[]} Skills que contienen el query en nombre, ID o descripción.
+ */
+function buscar(cwd, query) {
+  const indice = cargarIndice(cwd) || descubrir(cwd);
+  const q      = query.toLowerCase().trim();
+
+  if (!q) return indice.skills;
+
+  return indice.skills.filter(skill =>
+    skill.id.toLowerCase().includes(q) ||
+    skill.nombre.toLowerCase().includes(q) ||
+    skill.descripcion.toLowerCase().includes(q)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { descubrir, buscar, cargarIndice, escanear };
+
+// ---------------------------------------------------------------------------
+// CLI directo
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const cwd  = process.cwd();
+  const args = process.argv.slice(2);
+
+  // --rebuild fuerza re-escaneo incluso si el índice existe
+  const rebuild = args.includes('--rebuild');
+  const query   = args.filter(a => !a.startsWith('--'))[0] || '';
+
+  if (query) {
+    const resultados = buscar(cwd, query);
+    if (resultados.length === 0) {
+      process.stdout.write(`\nSin habilidades que coincidan con "${query}"\n\n`);
+    } else {
+      process.stdout.write(`\nHabilidades SWL — resultados para "${query}" (${resultados.length})\n`);
+      process.stdout.write('─'.repeat(70) + '\n');
+      for (const s of resultados) {
+        const id   = s.id.padEnd(42);
+        const ver  = `v${s.version}`.padEnd(8);
+        const desc = s.descripcion.slice(0, 50);
+        process.stdout.write(`  ${id}${ver}${desc}\n`);
+      }
+      process.stdout.write('\n');
+    }
+  } else {
+    const indice = rebuild ? descubrir(cwd) : (cargarIndice(cwd) || descubrir(cwd));
+    process.stdout.write(`\nÍndice de habilidades SWL (${indice.total} habilidades)\n`);
+    process.stdout.write('─'.repeat(70) + '\n');
+    for (const s of indice.skills) {
+      const id   = s.id.padEnd(42);
+      const ver  = `v${s.version}`.padEnd(8);
+      const desc = s.descripcion.slice(0, 50);
+      process.stdout.write(`  ${id}${ver}${desc}\n`);
+    }
+    process.stdout.write('─'.repeat(70) + '\n');
+    process.stdout.write(`Generado: ${indice.generadoEn.slice(0, 10)}  |  `);
+    process.stdout.write(`Índice: ${SKILL_INDEX}\n\n`);
+    process.stdout.write(`Uso: Skill("nombre-de-habilidad")\n\n`);
+  }
+}