@saulwade/swl-ses 1.0.0

package/hooks/lib/memory-search.js

@@ -0,0 +1,506 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Memory Search — Busqueda progresiva sobre la memoria SWL.
+ *
+ * 3 capas de busqueda (Progressive Disclosure):
+ *   1. search(query)    -> indices compactos (~50-100 tokens por resultado)
+ *   2. timeline(ids)    -> contexto cronologico (~200-500 tokens)
+ *   3. fetch(id)        -> detalle completo (~500-1000 tokens)
+ *
+ * Fuentes de datos:
+ *   - .planning/APRENDIZAJES.md (aprendizajes extraidos por hooks)
+ *   - .planning/sessions/*.json (sesiones persistidas)
+ *   - instintos/proyecto.yaml   (instintos con confidence)
+ *
+ * API publica:
+ *   search(baseDir, query, filtros?)   -> object[]  — Capa 1: indices
+ *   timeline(baseDir, ids)             -> object[]  — Capa 2: contexto cronologico
+ *   fetch(baseDir, id)                 -> object|null — Capa 3: detalle completo
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const sessionFts = require('./session-fts');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+/** Maximo de sesiones a escanear para evitar I/O excesivo. */
+const MAX_SESIONES_SCAN = 50;
+
+/** Longitud minima de un termino de busqueda para ser considerado. */
+const MIN_TERM_LENGTH = 2;
+
+/** Longitud maxima de titulo en resultados compactos. */
+const MAX_TITULO_LENGTH = 80;
+
+/** Longitud maxima de contenido en respuesta de timeline. */
+const MAX_CONTENIDO_TIMELINE = 500;
+
+// ---------------------------------------------------------------------------
+// Helpers internos
+// ---------------------------------------------------------------------------
+
+/**
+ * Divide una query en terminos utiles, descartando tokens muy cortos.
+ * @param {string} query
+ * @returns {string[]}
+ */
+function tokenizar(query) {
+  return String(query || '')
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(t => t.length > MIN_TERM_LENGTH);
+}
+
+/**
+ * Calcula la relevancia normalizada de un texto respecto a los terminos de busqueda.
+ * @param {string} texto
+ * @param {string[]} terminos
+ * @returns {number} Valor entre 0 y 1.
+ */
+function calcularRelevancia(texto, terminos) {
+  if (terminos.length === 0) return 0;
+  const textoLower = texto.toLowerCase();
+  const coincidencias = terminos.filter(t => textoLower.includes(t)).length;
+  return coincidencias / terminos.length;
+}
+
+// ---------------------------------------------------------------------------
+// Fuente: APRENDIZAJES.md
+// ---------------------------------------------------------------------------
+
+/**
+ * Busca en .planning/APRENDIZAJES.md por terminos de query.
+ * @param {string} baseDir
+ * @param {string[]} terminos - Resultado de tokenizar(query).
+ * @returns {object[]} Resultados compactos con id, tipo, titulo, fecha, relevancia.
+ */
+function buscarEnAprendizajes(baseDir, terminos) {
+  const aprendizajesPath = path.join(baseDir, '.planning', 'APRENDIZAJES.md');
+  if (!fs.existsSync(aprendizajesPath)) return [];
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(aprendizajesPath, 'utf8');
+  } catch (_) {
+    return [];
+  }
+
+  // Dividir por bloques H2 ("## Titulo")
+  const bloques = contenido.split(/^## /m).filter(Boolean);
+  const resultados = [];
+
+  for (let i = 0; i < bloques.length; i++) {
+    const bloque = bloques[i];
+    const primeraLinea = bloque.split('\n')[0].trim();
+    const relevancia = calcularRelevancia(bloque, terminos);
+
+    if (relevancia > 0) {
+      const fechaMatch = bloque.match(/\d{4}-\d{2}-\d{2}/);
+      resultados.push({
+        id:          `apr-${i}`,
+        tipo:        'aprendizaje',
+        titulo:      primeraLinea.slice(0, MAX_TITULO_LENGTH),
+        fecha:       fechaMatch ? fechaMatch[0] : 'sin-fecha',
+        relevancia,
+      });
+    }
+  }
+
+  return resultados;
+}
+
+/**
+ * Obtiene el bloque completo de un aprendizaje por indice.
+ * @param {string} baseDir
+ * @param {number} idx
+ * @returns {string|null}
+ */
+function obtenerBloqueAprendizaje(baseDir, idx) {
+  const aprendizajesPath = path.join(baseDir, '.planning', 'APRENDIZAJES.md');
+  if (!fs.existsSync(aprendizajesPath)) return null;
+
+  try {
+    const contenido = fs.readFileSync(aprendizajesPath, 'utf8');
+    const bloques   = contenido.split(/^## /m).filter(Boolean);
+    return bloques[idx] || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fuente: sessions/*.json
+// ---------------------------------------------------------------------------
+
+/**
+ * Busca en .planning/sessions/*.json usando el índice invertido TF-IDF.
+ *
+ * Reemplaza el scan lineal anterior con búsqueda indexada BM25.
+ * Fallback a scan lineal si el índice no está disponible.
+ *
+ * @param {string} baseDir
+ * @param {string[]} terminos
+ * @returns {object[]} Resultados compactos.
+ */
+function buscarEnSesiones(baseDir, terminos) {
+  const query = terminos.join(' ');
+  if (!query) return [];
+
+  try {
+    // Usar índice FTS (BM25 scoring, incremental, persistido)
+    const ftsResults = sessionFts.search(baseDir, query, { limit: MAX_SESIONES_SCAN });
+
+    return ftsResults.map(r => ({
+      id:        r.id,
+      tipo:      'sesion',
+      titulo:    (r.summary || `Sesion ${r.id}`).slice(0, MAX_TITULO_LENGTH),
+      fecha:     r.startTime ? r.startTime.split('T')[0] : 'sin-fecha',
+      relevancia: Math.min(r.score / 3, 1), // Normalizar BM25 score a 0-1
+      toolCalls: r.toolCalls,
+      costo:     r.cost,
+    }));
+  } catch (_) {
+    // Fallback a scan lineal si FTS falla
+    return _buscarEnSesionesFallback(baseDir, terminos);
+  }
+}
+
+/**
+ * Fallback: búsqueda lineal cuando FTS no está disponible.
+ * @param {string} baseDir
+ * @param {string[]} terminos
+ * @returns {object[]}
+ */
+function _buscarEnSesionesFallback(baseDir, terminos) {
+  const sessionsDir = path.join(baseDir, '.planning', 'sessions');
+  if (!fs.existsSync(sessionsDir)) return [];
+
+  let archivos;
+  try {
+    archivos = fs.readdirSync(sessionsDir)
+      .filter(f => f.startsWith('ses-') && f.endsWith('.json'))
+      .sort()
+      .reverse()
+      .slice(0, MAX_SESIONES_SCAN);
+  } catch (_) {
+    return [];
+  }
+
+  const resultados = [];
+
+  for (const archivo of archivos) {
+    let sesion;
+    try {
+      sesion = JSON.parse(
+        fs.readFileSync(path.join(sessionsDir, archivo), 'utf8'),
+      );
+    } catch (_) {
+      continue;
+    }
+
+    const textoIndexado = [
+      sesion.summary        || '',
+      sesion.mode           || '',
+      ...(sesion.filesChanged  || []),
+      ...(sesion.agentsInvoked || []),
+    ].join(' ');
+
+    const relevancia = calcularRelevancia(textoIndexado, terminos);
+
+    if (relevancia > 0) {
+      resultados.push({
+        id:        sesion.id,
+        tipo:      'sesion',
+        titulo:    (sesion.summary || `Sesion ${sesion.id}`).slice(0, MAX_TITULO_LENGTH),
+        fecha:     sesion.startTime ? sesion.startTime.split('T')[0] : 'sin-fecha',
+        relevancia,
+        toolCalls: sesion.toolCalls,
+        costo:     sesion.costEstimated,
+      });
+    }
+  }
+
+  return resultados;
+}
+
+/**
+ * Carga el objeto completo de una sesion por id.
+ * @param {string} baseDir
+ * @param {string} id - Ejemplo: "ses-20260325-143000"
+ * @returns {object|null}
+ */
+function obtenerSesion(baseDir, id) {
+  const sessionPath = path.join(baseDir, '.planning', 'sessions', `${id}.json`);
+  if (!fs.existsSync(sessionPath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fuente: instintos/proyecto.yaml
+// ---------------------------------------------------------------------------
+
+/**
+ * Busca en instintos/proyecto.yaml por terminos de query.
+ * Solo considera instintos con status "active".
+ * @param {string} baseDir
+ * @param {string[]} terminos
+ * @returns {object[]} Resultados compactos.
+ */
+function buscarEnInstintos(baseDir, terminos) {
+  const instPath = path.join(baseDir, 'instintos', 'proyecto.yaml');
+  if (!fs.existsSync(instPath)) return [];
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(instPath, 'utf8');
+  } catch (_) {
+    return [];
+  }
+
+  const resultados = [];
+  // Regex para extraer bloques de instinto del YAML (sin dependencia yaml parser)
+  const instRegex = /- id:\s*(\S+)[\s\S]*?pattern:\s*"([^"]+)"[\s\S]*?confidence:\s*([\d.]+)[\s\S]*?status:\s*(\w+)/g;
+  let match;
+
+  while ((match = instRegex.exec(contenido)) !== null) {
+    const [, id, pattern, confidenceStr, status] = match;
+    if (status !== 'active') continue;
+
+    const relevancia = calcularRelevancia(pattern, terminos);
+    if (relevancia > 0) {
+      resultados.push({
+        id:         id,
+        tipo:       'instinto',
+        titulo:     pattern.slice(0, MAX_TITULO_LENGTH),
+        fecha:      'permanente',
+        relevancia,
+        confidence: parseFloat(confidenceStr),
+      });
+    }
+  }
+
+  return resultados;
+}
+
+// ---------------------------------------------------------------------------
+// Capa 1: search
+// ---------------------------------------------------------------------------
+
+/**
+ * Busqueda compacta (Capa 1) — retorna indices con minimo de tokens.
+ *
+ * Uso tipico:
+ *   const resultados = search(baseDir, "error build Java");
+ *   // → [{id: "apr-5", tipo: "aprendizaje", titulo: "Fix classpath Maven...", ...}]
+ *
+ * @param {string} baseDir     - Directorio raiz del proyecto.
+ * @param {string} query       - Texto libre de busqueda.
+ * @param {object} [filtros]   - Filtros opcionales.
+ * @param {string} [filtros.tipo]         - 'aprendizaje' | 'sesion' | 'instinto'
+ * @param {string} [filtros.fecha_desde]  - Fecha ISO minima (YYYY-MM-DD)
+ * @param {string} [filtros.fecha_hasta]  - Fecha ISO maxima (YYYY-MM-DD)
+ * @param {number} [filtros.limit=20]     - Maximo de resultados
+ * @returns {object[]} Array de resultados compactos ordenados por relevancia.
+ */
+function search(baseDir, query, filtros = {}) {
+  const terminos = tokenizar(query);
+  if (terminos.length === 0) return [];
+
+  const limit = typeof filtros.limit === 'number' && filtros.limit > 0
+    ? filtros.limit
+    : 20;
+
+  let resultados = [];
+
+  if (!filtros.tipo || filtros.tipo === 'aprendizaje') {
+    resultados.push(...buscarEnAprendizajes(baseDir, terminos));
+  }
+  if (!filtros.tipo || filtros.tipo === 'sesion') {
+    resultados.push(...buscarEnSesiones(baseDir, terminos));
+  }
+  if (!filtros.tipo || filtros.tipo === 'instinto') {
+    resultados.push(...buscarEnInstintos(baseDir, terminos));
+  }
+
+  // Filtros de fecha (solo sobre resultados con fecha real)
+  if (filtros.fecha_desde) {
+    resultados = resultados.filter(
+      r => r.fecha === 'permanente' || r.fecha >= filtros.fecha_desde,
+    );
+  }
+  if (filtros.fecha_hasta) {
+    resultados = resultados.filter(
+      r => r.fecha === 'permanente' || r.fecha <= filtros.fecha_hasta,
+    );
+  }
+
+  return resultados
+    .sort((a, b) => b.relevancia - a.relevancia)
+    .slice(0, limit);
+}
+
+// ---------------------------------------------------------------------------
+// Capa 2: timeline
+// ---------------------------------------------------------------------------
+
+/**
+ * Contexto cronologico (Capa 2) — agrega contexto a los ids de Capa 1.
+ *
+ * Retorna los resultados agrupados cronologicamente con contenido resumido.
+ * Util para entender la secuencia de eventos antes de hacer fetch.
+ *
+ * Uso tipico:
+ *   const indices = search(baseDir, "error build Java");
+ *   const ids = indices.slice(0, 5).map(r => r.id);
+ *   const ctx = timeline(baseDir, ids);
+ *
+ * @param {string}   baseDir - Directorio raiz del proyecto.
+ * @param {string[]} ids     - IDs de resultados devueltos por search().
+ * @returns {object[]} Array de entradas con contexto cronologico, descendente por fecha.
+ */
+function timeline(baseDir, ids) {
+  if (!Array.isArray(ids) || ids.length === 0) return [];
+
+  const entradas = [];
+
+  for (const id of ids) {
+    if (typeof id !== 'string') continue;
+
+    if (id.startsWith('apr-')) {
+      const idx    = parseInt(id.split('-')[1], 10);
+      const bloque = obtenerBloqueAprendizaje(baseDir, idx);
+      if (!bloque) continue;
+
+      const titulo    = bloque.split('\n')[0].trim();
+      const fechaMatch = bloque.match(/\d{4}-\d{2}-\d{2}/);
+      entradas.push({
+        id,
+        tipo:     'aprendizaje',
+        titulo:   titulo.slice(0, MAX_TITULO_LENGTH),
+        contenido: bloque.slice(0, MAX_CONTENIDO_TIMELINE),
+        fecha:    fechaMatch ? fechaMatch[0] : 'sin-fecha',
+      });
+
+    } else if (id.startsWith('ses-')) {
+      const sesion = obtenerSesion(baseDir, id);
+      if (!sesion) continue;
+
+      entradas.push({
+        id,
+        tipo:     'sesion',
+        titulo:   (sesion.summary || `Sesion ${sesion.id}`).slice(0, MAX_TITULO_LENGTH),
+        contenido: [
+          `Modo: ${sesion.mode || 'desconocido'}`,
+          `Tool calls: ${sesion.toolCalls || 0}`,
+          `Costo estimado: $${(sesion.costEstimated || 0).toFixed(2)}`,
+          `Archivos: ${(sesion.filesChanged || []).join(', ') || 'ninguno'}`,
+          `Agentes: ${(sesion.agentsInvoked || []).join(', ') || 'ninguno'}`,
+          `Resumen: ${(sesion.summary || '').slice(0, 300)}`,
+        ].join(' | '),
+        fecha: sesion.startTime ? sesion.startTime.split('T')[0] : 'sin-fecha',
+      });
+
+    } else {
+      // Instinto u otro tipo no iterable — entrada minima
+      entradas.push({
+        id,
+        tipo:     'instinto',
+        titulo:   `Instinto ${id}`,
+        contenido: `Ver instintos/proyecto.yaml para detalle del instinto ${id}.`,
+        fecha:    'permanente',
+      });
+    }
+  }
+
+  // Orden descendente por fecha (permanente va al final)
+  return entradas.sort((a, b) => {
+    if (a.fecha === 'permanente' && b.fecha === 'permanente') return 0;
+    if (a.fecha === 'permanente') return 1;
+    if (b.fecha === 'permanente') return -1;
+    return b.fecha.localeCompare(a.fecha);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Capa 3: fetch
+// ---------------------------------------------------------------------------
+
+/**
+ * Detalle completo (Capa 3) — carga el contenido completo de un resultado.
+ *
+ * Usar SOLO para los 1-3 resultados mas relevantes tras revisar timeline.
+ * Traer todos los resultados con fetch anula el ahorro de tokens.
+ *
+ * Uso tipico:
+ *   const detalle = fetch(baseDir, "apr-5");
+ *   // → { id, tipo, contenido: "<bloque completo>" }
+ *
+ * @param {string} baseDir - Directorio raiz del proyecto.
+ * @param {string} id      - ID de un resultado de search().
+ * @returns {object|null}  Objeto con contenido completo, o null si no existe.
+ */
+function fetch(baseDir, id) {
+  if (typeof id !== 'string') return null;
+
+  if (id.startsWith('apr-')) {
+    const idx    = parseInt(id.split('-')[1], 10);
+    const bloque = obtenerBloqueAprendizaje(baseDir, idx);
+    if (!bloque) return null;
+
+    return {
+      id,
+      tipo:     'aprendizaje',
+      contenido: bloque,
+    };
+  }
+
+  if (id.startsWith('ses-')) {
+    const sesion = obtenerSesion(baseDir, id);
+    if (!sesion) return null;
+
+    return {
+      id,
+      tipo:     'sesion',
+      contenido: sesion,
+    };
+  }
+
+  // Instinto: retornar bloque YAML del instinto especifico
+  const instPath = path.join(baseDir, 'instintos', 'proyecto.yaml');
+  if (fs.existsSync(instPath)) {
+    try {
+      const contenido = fs.readFileSync(instPath, 'utf8');
+      // Extraer solo el bloque del instinto solicitado
+      const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const bloqueMatch = contenido.match(
+        new RegExp(`- id:\\s*${escapedId}[\\s\\S]*?(?=\\n- id:|$)`, 'm'),
+      );
+      if (bloqueMatch) {
+        return {
+          id,
+          tipo:     'instinto',
+          contenido: bloqueMatch[0],
+        };
+      }
+    } catch (_) {}
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { search, timeline, fetch };

package/hooks/lib/merkle-audit.js

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * Merkle Audit — Trail de auditoria con hash-chain criptografica.
+ *
+ * Adoptado de OpenFang (SECURITY.md: Merkle Hash-Chain Audit Trail).
+ * Cada entrada incluye el hash de la entrada anterior, formando una cadena
+ * inmutable. Cualquier edicion del archivo se detecta por rotura de la cadena.
+ *
+ * A diferencia de audit-trail.js (JSONL append-only sin verificacion),
+ * merkle-audit garantiza integridad criptografica.
+ *
+ * Zero dependencias externas.
+ *
+ * @module hooks/lib/merkle-audit
+ */
+
+const crypto = require('crypto');
+const fs     = require('fs');
+
+function _sha256(data) {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+function crearEntrada(datos, hashAnterior) {
+  const payload = JSON.stringify({
+    ts: new Date().toISOString(),
+    tool: datos.tool || '',
+    action: datos.action || '',
+    target: datos.target || '',
+    agent: datos.agent || '',
+    result: datos.result || 'ok',
+    prev: hashAnterior,
+  });
+  const hash = _sha256(payload);
+  return { payload, hash };
+}
+
+function appendAudit(rutaArchivo, datos) {
+  let hashAnterior = '0'.repeat(64);
+
+  if (fs.existsSync(rutaArchivo)) {
+    try {
+      const contenido = fs.readFileSync(rutaArchivo, 'utf8').trim();
+      const lineas = contenido.split('\n').filter(Boolean);
+      if (lineas.length > 0) {
+        const ultima = JSON.parse(lineas[lineas.length - 1]);
+        hashAnterior = ultima.hash || hashAnterior;
+      }
+    } catch { /* archivo corrupto, empezar nueva cadena */ }
+  }
+
+  const { payload, hash } = crearEntrada(datos, hashAnterior);
+  const linea = JSON.stringify({ ...JSON.parse(payload), hash }) + '\n';
+  fs.appendFileSync(rutaArchivo, linea, 'utf8');
+  return hash;
+}
+
+function verificarCadena(rutaArchivo) {
+  if (!fs.existsSync(rutaArchivo)) return { valido: true, entradas: 0 };
+
+  const contenido = fs.readFileSync(rutaArchivo, 'utf8').trim();
+  const lineas = contenido.split('\n').filter(Boolean);
+  let hashEsperado = '0'.repeat(64);
+  let roturaEn = -1;
+
+  for (let i = 0; i < lineas.length; i++) {
+    try {
+      const entrada = JSON.parse(lineas[i]);
+      if (entrada.prev !== hashEsperado) {
+        roturaEn = i;
+        break;
+      }
+      const { hash: storedHash, ...resto } = entrada;
+      const payloadRecalc = JSON.stringify(resto);
+      const hashRecalc = _sha256(payloadRecalc);
+      if (hashRecalc !== storedHash) {
+        roturaEn = i;
+        break;
+      }
+      hashEsperado = storedHash;
+    } catch {
+      roturaEn = i;
+      break;
+    }
+  }
+
+  return {
+    valido: roturaEn === -1,
+    entradas: lineas.length,
+    roturaEn: roturaEn === -1 ? null : roturaEn,
+    ultimoHash: hashEsperado,
+  };
+}
+
+module.exports = { appendAudit, verificarCadena, crearEntrada };