@saulwade/swl-ses 1.1.4 → 1.2.0

package/scripts/mcp-server/handlers.js

@@ -0,0 +1,206 @@
+'use strict';
+
+/**
+ * handlers.js — Handlers para los 3 endpoints MCP stub de swl-ses.
+ *
+ * **EXPERIMENTAL** — no producción. Sin auth, sin rate limiting, sin
+ * tests robustos. Ver `scripts/mcp-server/README.md` para limitaciones.
+ *
+ * Los handlers leen el estado file-based de swl-ses (APRENDIZAJES.md,
+ * .planning/sessions/, instintos/proyecto.yaml) y devuelven datos
+ * estructurados al cliente MCP. NO escriben — solo lectura.
+ *
+ * @module scripts/mcp-server/handlers
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const memorySearch       = require('../../hooks/lib/memory-search');
+const scoringInstintos   = require('../lib/scoring-instintos');
+
+// ── handler: swl_memory_search ────────────────────────────────────────────────
+
+/**
+ * Búsqueda hybrid sobre memoria SWL (aprendizajes + sesiones + instintos).
+ *
+ * @param {object} args - { query: string, limit?: number, tipo?: string }
+ * @returns {object} { results: Array, count: number }
+ */
+function swlMemorySearch(baseDir, args) {
+  if (!args || typeof args.query !== 'string' || !args.query.trim()) {
+    return { error: 'query (string) requerido', results: [] };
+  }
+
+  const filtros = {};
+  if (typeof args.limit === 'number' && args.limit > 0) filtros.limit = Math.min(args.limit, 50);
+  if (typeof args.tipo === 'string') filtros.tipo = args.tipo;
+
+  const results = memorySearch.search(baseDir, args.query, filtros);
+  return {
+    results: results.map(r => ({
+      id: r.id,
+      tipo: r.tipo,
+      titulo: r.titulo,
+      fecha: r.fecha,
+      relevancia: r.relevancia,
+      combinedScore: r.combinedScore,
+    })),
+    count: results.length,
+  };
+}
+
+// ── handler: swl_aprendizajes_recientes ───────────────────────────────────────
+
+/**
+ * Devuelve los N aprendizajes más recientes de APRENDIZAJES.md.
+ *
+ * @param {object} args - { limit?: number (default 10) }
+ * @returns {object} { results, count }
+ */
+function swlAprendizajesRecientes(baseDir, args = {}) {
+  const limit = (typeof args.limit === 'number' && args.limit > 0)
+    ? Math.min(args.limit, 50)
+    : 10;
+
+  const ruta = path.join(baseDir, '.planning', 'APRENDIZAJES.md');
+  if (!fs.existsSync(ruta)) {
+    return { error: 'APRENDIZAJES.md no encontrado', results: [] };
+  }
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(ruta, 'utf8');
+  } catch (err) {
+    return { error: 'Error de lectura: ' + err.message, results: [] };
+  }
+
+  const bloques = contenido.split(/^## /m).filter(b => b.trim().length > 0);
+  // Los más recientes están al FINAL del archivo (append-only por convención)
+  const recientes = bloques.slice(-limit).reverse();
+
+  return {
+    results: recientes.map((b, i) => {
+      const primeraLinea = b.split('\n')[0].trim();
+      const cuerpoTrim = b.split('\n').slice(1).join('\n').trim().slice(0, 500);
+      return {
+        index: bloques.length - i,
+        titulo: primeraLinea,
+        contenido: cuerpoTrim,
+      };
+    }),
+    count: recientes.length,
+    total: bloques.length,
+  };
+}
+
+// ── handler: swl_instintos_activos ────────────────────────────────────────────
+
+/**
+ * Devuelve instintos con effective_confidence ≥ umbral.
+ *
+ * @param {object} args - { minConfidence?: number (default 0.5), limit?: number }
+ * @returns {object} { results, count }
+ */
+function swlInstintosActivos(baseDir, args = {}) {
+  const minConfidence = (typeof args.minConfidence === 'number')
+    ? args.minConfidence : 0.5;
+  const limit = (typeof args.limit === 'number' && args.limit > 0)
+    ? Math.min(args.limit, 100) : 20;
+
+  const ruta = path.join(baseDir, 'instintos', 'proyecto.yaml');
+  if (!fs.existsSync(ruta)) {
+    return { error: 'instintos/proyecto.yaml no encontrado', results: [] };
+  }
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(ruta, 'utf8');
+  } catch (err) {
+    return { error: 'Error de lectura: ' + err.message, results: [] };
+  }
+
+  // Parser simple sin dep YAML (mismo patrón que memory-search.js)
+  const instinto_re = /- id:\s*(\S+)[\s\S]*?pattern:\s*"([^"]+)"[\s\S]*?confidence:\s*([\d.]+)[\s\S]*?status:\s*(\w+)/g;
+  const results = [];
+  let match;
+  const ahora = new Date();
+
+  while ((match = instinto_re.exec(contenido)) !== null) {
+    const [, id, pattern, confidenceStr, status] = match;
+    const confidence = parseFloat(confidenceStr);
+    if (status !== 'active') continue;
+
+    // Construir objeto mínimo para scoring
+    const instinto = {
+      id,
+      pattern,
+      confidence,
+      status,
+      // Sin más metadata, effective_confidence ≈ confidence
+    };
+    const effective = scoringInstintos.effectiveConfidence(instinto, ahora);
+    if (effective < minConfidence) continue;
+
+    results.push({
+      id,
+      pattern,
+      confidence,
+      effective_confidence: Math.round(effective * 1000) / 1000,
+      status,
+    });
+  }
+
+  results.sort((a, b) => b.effective_confidence - a.effective_confidence);
+  return {
+    results: results.slice(0, limit),
+    count: Math.min(results.length, limit),
+    total: results.length,
+  };
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+
+const HANDLERS = {
+  swl_memory_search: {
+    description: 'Búsqueda hybrid sobre memoria SWL (aprendizajes + sesiones + instintos) con RRF fusion.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Texto libre de búsqueda' },
+        limit: { type: 'number', description: 'Máximo de resultados (default 20, max 50)' },
+        tipo:  { type: 'string', enum: ['aprendizaje', 'sesion', 'instinto'], description: 'Filtrar por tipo' },
+      },
+      required: ['query'],
+    },
+    handler: swlMemorySearch,
+  },
+  swl_aprendizajes_recientes: {
+    description: 'Últimos N aprendizajes de .planning/APRENDIZAJES.md (más recientes primero).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Cuántos retornar (default 10, max 50)' },
+      },
+    },
+    handler: swlAprendizajesRecientes,
+  },
+  swl_instintos_activos: {
+    description: 'Instintos con effective_confidence ≥ umbral. Default 0.5.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        minConfidence: { type: 'number', description: 'Umbral mínimo (default 0.5)' },
+        limit: { type: 'number', description: 'Máximo (default 20, max 100)' },
+      },
+    },
+    handler: swlInstintosActivos,
+  },
+};
+
+module.exports = {
+  HANDLERS,
+  swlMemorySearch,
+  swlAprendizajesRecientes,
+  swlInstintosActivos,
+};

package/scripts/run-eval.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * run-eval.js — CLI para ejecutar evaluaciones del eval framework.
+ *
+ * Uso:
+ *   node scripts/run-eval.js <ruta-eval.json>
+ *
+ * Formato del archivo JSON de eval:
+ * {
+ *   "functionId": "memoria-busqueda::search",
+ *   "schemaName": "MEMORY_SEARCH_RESULT_SCHEMA",   // opcional, valida output
+ *   "qualityScorer": "scoreObservacion",           // opcional, calcula calidad
+ *   "input":  { ... },                              // datos de entrada
+ *   "expectedKeys": ["id", "tipo", "titulo"],       // opcional, valida presencia
+ *   "output": { ... }                               // output a evaluar
+ * }
+ *
+ * Exit codes:
+ *   0 - eval pasa (valid: true)
+ *   1 - eval falla (valid: false) o error de I/O
+ *   2 - error de uso (argumentos inválidos)
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const schemas         = require('./lib/eval-schemas');
+const validator       = require('./lib/eval-validator');
+const quality         = require('./lib/eval-quality');
+const metricsStore    = require('./lib/eval-metrics-store');
+
+function uso() {
+  console.error('Uso: node scripts/run-eval.js <ruta-eval.json>');
+  console.error('     node scripts/run-eval.js --rebuild-aggregate');
+  process.exit(2);
+}
+
+function ejecutarEval(ruta) {
+  if (!fs.existsSync(ruta)) {
+    console.error(`Archivo no existe: ${ruta}`);
+    return 1;
+  }
+
+  let definicion;
+  try {
+    definicion = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+  } catch (err) {
+    console.error(`Error parseando ${ruta}: ${err.message}`);
+    return 1;
+  }
+
+  const { functionId, schemaName, qualityScorer, output } = definicion;
+  if (!functionId || typeof functionId !== 'string') {
+    console.error('functionId requerido en el archivo de eval');
+    return 1;
+  }
+
+  const inicio = Date.now();
+  let valid = true;
+  let errors = [];
+  let qualityScore = null;
+
+  // Validar contra schema si se especifica
+  if (schemaName) {
+    const schema = schemas[schemaName];
+    if (!schema) {
+      console.error(`Schema desconocido: ${schemaName}. Disponibles: ${Object.keys(schemas).filter(k => k.endsWith('_SCHEMA')).join(', ')}`);
+      return 1;
+    }
+    const r = validator.validar(output, schema);
+    valid = valid && r.valid;
+    if (!r.valid) errors.push(...r.errors);
+  }
+
+  // Validar campos esperados si se especifican
+  if (Array.isArray(definicion.expectedKeys)) {
+    for (const key of definicion.expectedKeys) {
+      if (!output || !(key in output)) {
+        valid = false;
+        errors.push(`expectedKey faltante: ${key}`);
+      }
+    }
+  }
+
+  // Calcular quality score si se especifica
+  if (qualityScorer) {
+    const scorer = quality[qualityScorer];
+    if (typeof scorer !== 'function') {
+      console.error(`Quality scorer desconocido: ${qualityScorer}. Disponibles: ${Object.keys(quality).join(', ')}`);
+      return 1;
+    }
+    qualityScore = scorer(output);
+  }
+
+  const latencyMs = Date.now() - inicio;
+  const exito = valid;
+
+  // Persistir resultado
+  const baseDir = process.cwd();
+  metricsStore.registrar(baseDir, {
+    functionId,
+    latencyMs,
+    success: exito,
+    qualityScore,
+    metadata: { schemaName, qualityScorer, evalFile: path.basename(ruta) },
+  });
+
+  // Reportar
+  console.log(JSON.stringify({
+    functionId,
+    valid,
+    errors: errors.length > 0 ? errors : undefined,
+    qualityScore,
+    latencyMs,
+  }, null, 2));
+
+  return valid ? 0 : 1;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) uso();
+
+  if (args[0] === '--rebuild-aggregate') {
+    const r = metricsStore.reconstruirAgregado(process.cwd());
+    console.log(`Agregado reconstruido: ${r.rebuilt} eventos, ${r.functions} funciones únicas.`);
+    process.exit(0);
+  }
+
+  process.exit(ejecutarEval(args[0]));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  ejecutarEval,
+};