@saulwade/swl-ses 1.4.2 → 1.5.0

package/scripts/mcp-server/handlers.js

@@ -1,10 +1,10 @@
 'use strict';
 
 /**
- * handlers.js — Handlers para los 3 endpoints MCP stub de swl-ses.
+ * handlers.js — Handlers para los 3 endpoints MCP del swl-mcp-server.
  *
- * **EXPERIMENTAL** — no producción. Sin auth, sin rate limiting, sin
- * tests robustos. Ver `scripts/mcp-server/README.md` para limitaciones.
+ * v1.0.0 (ADR-0019 Sub-fase 3): integra caching mtime-based desde
+ * `scripts/mcp-server/cache.js`. Sigue siendo solo lectura.
  *
  * Los handlers leen el estado file-based de swl-ses (APRENDIZAJES.md,
  * .planning/sessions/, instintos/proyecto.yaml) y devuelven datos
@@ -18,6 +18,11 @@ const path = require('path');
 
 const memorySearch       = require('../../hooks/lib/memory-search');
 const scoringInstintos   = require('../lib/scoring-instintos');
+const { crearCache }     = require('./cache');
+
+// Cache singleton — compartido entre handlers para reducir IO en lecturas repetidas.
+// mtime-based, invalidación automática cuando el archivo cambia. ADR-0019 Sub-fase 3.
+const cache = crearCache();
 
 // ── handler: swl_memory_search ────────────────────────────────────────────────
 
@@ -64,18 +69,18 @@ function swlAprendizajesRecientes(baseDir, args = {}) {
     : 10;
 
   const ruta = path.join(baseDir, '.planning', 'APRENDIZAJES.md');
-  if (!fs.existsSync(ruta)) {
-    return { error: 'APRENDIZAJES.md no encontrado', results: [] };
-  }
-
-  let contenido;
+  let cached;
   try {
-    contenido = fs.readFileSync(ruta, 'utf8');
+    cached = cache.get(ruta, (contenido) => {
+      const bloques = contenido.split(/^## /m).filter(b => b.trim().length > 0);
+      return { bloques };
+    });
   } catch (err) {
     return { error: 'Error de lectura: ' + err.message, results: [] };
   }
+  if (!cached) return { error: 'APRENDIZAJES.md no encontrado', results: [] };
 
-  const bloques = contenido.split(/^## /m).filter(b => b.trim().length > 0);
+  const { bloques } = cached.data;
   // Los más recientes están al FINAL del archivo (append-only por convención)
   const recientes = bloques.slice(-limit).reverse();
 
@@ -159,11 +164,156 @@ function swlInstintosActivos(baseDir, args = {}) {
   };
 }
 
+// ── handler: swl_list_skills ──────────────────────────────────────────────────
+
+/**
+ * Lista los skills disponibles (nombre + descripción del frontmatter).
+ *
+ * Sub-fase 9 (v1.5.0). Útil para clientes MCP que no cargan skills filesystem
+ * nativamente y necesitan descubrir qué skills existen antes de invocarlos
+ * con swl_invoke_skill.
+ *
+ * Resolución del directorio de skills:
+ *   1. Si baseDir tiene `habilidades/`, usar ese (repo SWL como project root).
+ *   2. Si baseDir tiene `.claude/skills/`, usar ese (proyecto consumidor con SWL instalado).
+ *   3. Si baseDir tiene `.cursor/skills/`, usar ese.
+ *   4. Si nada de eso, devolver error.
+ *
+ * @param {string} baseDir
+ * @param {object} args - { dominio?: string, limit?: number }
+ */
+function swlListSkills(baseDir, args = {}) {
+  const dirSkills = resolverDirSkills(baseDir);
+  if (!dirSkills) {
+    return { error: 'No se encontró directorio de skills (habilidades/, .claude/skills/, .cursor/skills/)', results: [] };
+  }
+
+  const limit = (typeof args.limit === 'number' && args.limit > 0)
+    ? Math.min(args.limit, 500) : 200;
+  const dominio = typeof args.dominio === 'string' ? args.dominio.toLowerCase() : null;
+
+  let nombres;
+  try {
+    nombres = fs.readdirSync(dirSkills, { withFileTypes: true })
+      .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+      .map(d => d.name);
+  } catch (err) {
+    return { error: 'Error leyendo directorio: ' + err.message, results: [] };
+  }
+
+  const results = [];
+  for (const nombre of nombres) {
+    if (dominio && !nombre.toLowerCase().includes(dominio)) continue;
+    const skillMd = path.join(dirSkills, nombre, 'SKILL.md');
+    if (!fs.existsSync(skillMd)) continue;
+    try {
+      const contenido = fs.readFileSync(skillMd, 'utf-8');
+      const descMatch = contenido.match(/description:\s*>?\s*\n?\s*(.+?)(?=\n\w+:|\n---)/s);
+      const descripcion = descMatch ? descMatch[1].replace(/\s+/g, ' ').trim() : '';
+      results.push({
+        nombre,
+        descripcion: descripcion.length > 300 ? descripcion.slice(0, 297) + '...' : descripcion,
+      });
+    } catch { /* skill ilegible — saltar */ }
+    if (results.length >= limit) break;
+  }
+
+  return { results, count: results.length, total: nombres.length, dir: dirSkills };
+}
+
+// ── handler: swl_invoke_skill ─────────────────────────────────────────────────
+
+/**
+ * Devuelve el contenido completo de un SKILL.md por nombre.
+ *
+ * Sub-fase 9 (v1.5.0). Útil para clientes MCP donde el cliente NO carga skills
+ * filesystem nativamente (Codex CLI en `--local`, Gemini CLI, otros) pero quiere
+ * acceder a conocimiento operacional SWL. El cliente recibe el cuerpo completo
+ * del SKILL.md y puede usarlo como contexto en su próxima llamada.
+ *
+ * Limitaciones aceptadas:
+ *  - NO ejecuta scripts del skill — solo devuelve el SKILL.md como texto.
+ *  - Si el skill referencia `recursos/X.md`, el cliente debe pedirlo aparte
+ *    (no implementamos retrieval recursivo en v1.5.0).
+ *  - El cuerpo se trunca a 100 KB para no saturar el contexto del cliente.
+ *
+ * @param {string} baseDir
+ * @param {object} args - { nombre: string }
+ */
+function swlInvokeSkill(baseDir, args) {
+  if (!args || typeof args.nombre !== 'string' || !args.nombre.trim()) {
+    return { error: 'argumento "nombre" (string) requerido' };
+  }
+  // Sanitización: solo nombres en kebab-case (prevenir path traversal).
+  const nombre = args.nombre.trim();
+  if (!/^[a-z0-9][a-z0-9-]{0,62}$/i.test(nombre)) {
+    return { error: 'Nombre de skill inválido. Solo [a-zA-Z0-9-], 1-63 caracteres.' };
+  }
+
+  const dirSkills = resolverDirSkills(baseDir);
+  if (!dirSkills) {
+    return { error: 'No se encontró directorio de skills (habilidades/, .claude/skills/, .cursor/skills/)' };
+  }
+
+  const skillMd = path.join(dirSkills, nombre, 'SKILL.md');
+  if (!fs.existsSync(skillMd)) {
+    return { error: `Skill "${nombre}" no encontrado en ${dirSkills}` };
+  }
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(skillMd, 'utf-8');
+  } catch (err) {
+    return { error: 'Error leyendo SKILL.md: ' + err.message };
+  }
+
+  const MAX = 100 * 1024;
+  let truncado = false;
+  if (Buffer.byteLength(contenido, 'utf-8') > MAX) {
+    contenido = contenido.slice(0, MAX) + '\n\n> NOTA: contenido truncado a 100 KB.';
+    truncado = true;
+  }
+
+  // Listar recursos disponibles (sin leerlos) para que el cliente sepa qué pedir.
+  const recursos = [];
+  const dirRecursos = path.join(dirSkills, nombre, 'recursos');
+  if (fs.existsSync(dirRecursos)) {
+    try {
+      const archivos = fs.readdirSync(dirRecursos)
+        .filter(f => /\.(md|json|yaml|yml|txt)$/i.test(f));
+      recursos.push(...archivos.map(f => `recursos/${f}`));
+    } catch { /* sin recursos */ }
+  }
+
+  return { nombre, contenido, truncado, recursos, fuente: skillMd };
+}
+
+/**
+ * Resuelve el directorio de skills en el orden de precedencia:
+ *   1. baseDir/habilidades/  (repo SWL como project root)
+ *   2. baseDir/.claude/skills/  (proyecto consumidor con SWL instalado en Claude)
+ *   3. baseDir/.cursor/skills/  (proyecto con SWL instalado en Cursor)
+ *
+ * Retorna null si ninguno existe.
+ */
+function resolverDirSkills(baseDir) {
+  const candidatos = [
+    path.join(baseDir, 'habilidades'),
+    path.join(baseDir, '.claude', 'skills'),
+    path.join(baseDir, '.cursor', 'skills'),
+  ];
+  for (const dir of candidatos) {
+    if (fs.existsSync(dir)) return dir;
+  }
+  return null;
+}
+
 // ── exports ───────────────────────────────────────────────────────────────────
 
 const HANDLERS = {
   swl_memory_search: {
     description: 'Búsqueda hybrid sobre memoria SWL (aprendizajes + sesiones + instintos) con RRF fusion.',
+    schemaVersion: '1.0.0',
     inputSchema: {
       type: 'object',
       properties: {
@@ -177,6 +327,7 @@ const HANDLERS = {
   },
   swl_aprendizajes_recientes: {
     description: 'Últimos N aprendizajes de .planning/APRENDIZAJES.md (más recientes primero).',
+    schemaVersion: '1.0.0',
     inputSchema: {
       type: 'object',
       properties: {
@@ -187,6 +338,7 @@ const HANDLERS = {
   },
   swl_instintos_activos: {
     description: 'Instintos con effective_confidence ≥ umbral. Default 0.5.',
+    schemaVersion: '1.0.0',
     inputSchema: {
       type: 'object',
       properties: {
@@ -196,6 +348,30 @@ const HANDLERS = {
     },
     handler: swlInstintosActivos,
   },
+  swl_list_skills: {
+    description: 'Lista skills SWL disponibles (nombre + descripción). Útil para descubrir conocimiento operacional antes de invocar swl_invoke_skill.',
+    schemaVersion: '1.0.0',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dominio: { type: 'string', description: 'Filtro substring por nombre (opcional)' },
+        limit:   { type: 'number', description: 'Máximo (default 200, max 500)' },
+      },
+    },
+    handler: swlListSkills,
+  },
+  swl_invoke_skill: {
+    description: 'Devuelve el SKILL.md completo de un skill SWL por nombre. Para clientes MCP que no cargan skills filesystem nativamente — el cliente recibe el cuerpo y lo usa como contexto.',
+    schemaVersion: '1.0.0',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        nombre: { type: 'string', description: 'Nombre del skill (kebab-case, ej. fastapi-experto)' },
+      },
+      required: ['nombre'],
+    },
+    handler: swlInvokeSkill,
+  },
 };
 
 module.exports = {
@@ -203,4 +379,8 @@ module.exports = {
   swlMemorySearch,
   swlAprendizajesRecientes,
   swlInstintosActivos,
+  swlListSkills,
+  swlInvokeSkill,
+  // Expuesto para tests — permite invalidar el cache singleton entre runs.
+  _cache: cache,
 };

package/scripts/mcp-server/telemetry.js

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * Telemetría opt-in del swl-mcp-server v1.0.0 (ADR-0019 Sub-fase 3).
+ *
+ * Cuando `SWL_MCP_METRICS=1` está activo, cada `tools/call` se registra en
+ * `.planning/evolucion/mcp-metrics.jsonl` con:
+ *   { ts, tool, durationMs, ok, error?, baseDir }
+ *
+ * Defaults:
+ *   - SWL_MCP_METRICS no set → no se persiste nada (zero-cost).
+ *   - Se usa append-only JSONL (alta frecuencia → atomicWriteJSON sería ineficiente).
+ *   - Si el filesystem no permite escritura (p.ej. baseDir read-only), el error
+ *     se traga silenciosamente — la telemetría NUNCA debe romper el server.
+ *
+ * Zero-deps.
+ *
+ * @module scripts/mcp-server/telemetry
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Construye un grabador de telemetría desde el entorno actual.
+ *
+ * @param {object} [opciones]
+ * @param {string} opciones.baseDir - Directorio raíz del proyecto SWL (donde está .planning/).
+ * @param {object} [opciones.env] - Sustituible para tests.
+ * @returns {{ habilitada: boolean, registrar: Function, ruta: string|null }}
+ */
+function construirTelemetria(opciones = {}) {
+  const env = opciones.env || process.env;
+  const habilitada = env.SWL_MCP_METRICS === '1' || env.SWL_MCP_METRICS === 'true';
+  const baseDir = opciones.baseDir;
+
+  if (!habilitada || !baseDir) {
+    return {
+      habilitada: false,
+      registrar: () => {}, // noop
+      ruta: null,
+    };
+  }
+
+  const dirEvolucion = path.join(baseDir, '.planning', 'evolucion');
+  const ruta = path.join(dirEvolucion, 'mcp-metrics.jsonl');
+
+  // Asegurar que el directorio existe — si falla, deshabilitamos silenciosamente.
+  let escribible = true;
+  try {
+    fs.mkdirSync(dirEvolucion, { recursive: true });
+  } catch (err) {
+    escribible = false;
+  }
+
+  return {
+    habilitada: escribible,
+    registrar: (evento) => {
+      if (!escribible) return;
+      try {
+        const linea = JSON.stringify({
+          ts: new Date().toISOString(),
+          ...evento,
+        }) + '\n';
+        fs.appendFileSync(ruta, linea, { encoding: 'utf-8' });
+      } catch {
+        // Telemetría nunca debe romper el server — error silencioso.
+        // Tras 5 errores consecutivos podríamos deshabilitar, pero no
+        // implementamos eso hasta que aparezca como problema real.
+      }
+    },
+    ruta,
+  };
+}
+
+module.exports = {
+  construirTelemetria,
+};