@saulwade/swl-ses 1.0.0

package/scripts/lib/detectar-stack.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * detectar-stack.js
+ * Detecta el stack tecnológico de un proyecto para filtrar reglas de lenguaje.
+ * Evita instalar reglas irrelevantes en .claude/rules/ (reduce contexto auto-cargado).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Indicadores por lenguaje.
+ * - archivos: rutas exactas relativas al directorio del proyecto
+ * - extensiones: extensiones de archivo buscadas en top-2 niveles
+ * - directorios: subdirectorios cuya existencia confirma el lenguaje
+ */
+const INDICADORES = {
+  java: {
+    archivos: ['pom.xml', 'build.gradle', 'build.gradle.kts', '.mvn/wrapper/maven-wrapper.properties'],
+    extensiones: ['.java'],
+    directorios: ['src/main/java'],
+  },
+  go: {
+    archivos: ['go.mod', 'go.sum'],
+    extensiones: ['.go'],
+  },
+  rust: {
+    archivos: ['Cargo.toml', 'Cargo.lock'],
+    extensiones: ['.rs'],
+  },
+  csharp: {
+    extensiones: ['.csproj', '.sln', '.cs'],
+    directorios: [],
+  },
+  kotlin: {
+    extensiones: ['.kt', '.kts'],
+    directorios: [],
+  },
+  swift: {
+    archivos: ['Package.swift'],
+    extensiones: ['.swift'],
+    directorios: ['Sources'],
+  },
+  php: {
+    archivos: ['composer.json', 'artisan'],
+    extensiones: ['.php'],
+  },
+  nextjs: {
+    archivos: [
+      'next.config.js',
+      'next.config.ts',
+      'next.config.mjs',
+      'next.config.cjs',
+    ],
+  },
+};
+
+/**
+ * Lenguajes que tienen reglas en reglas/lenguajes/
+ * También exportado como LENGUAJES_CONOCIDOS para la limpieza en instalador.js
+ */
+const LENGUAJES_CON_REGLAS = new Set(Object.keys(INDICADORES));
+const LENGUAJES_CONOCIDOS = LENGUAJES_CON_REGLAS; // alias semántico
+
+/**
+ * Detecta los lenguajes/frameworks presentes en el directorio del proyecto.
+ * @param {string} dirProyecto - Directorio raíz del proyecto
+ * @returns {Set<string>} Conjunto de lenguajes detectados (e.g., Set{'java', 'nextjs'})
+ */
+function detectarStack(dirProyecto) {
+  const detectados = new Set();
+
+  for (const [lang, indicadores] of Object.entries(INDICADORES)) {
+    if (_tieneIndicador(dirProyecto, indicadores)) {
+      detectados.add(lang);
+    }
+  }
+
+  return detectados;
+}
+
+/**
+ * Filtra los archivos de la resolución de perfil para excluir reglas de
+ * lenguajes NO detectados en el proyecto.
+ *
+ * @param {Array} archivos - resolucion.archivos del perfil resuelto
+ * @param {Set<string>} stackDetectado - lenguajes detectados por detectarStack()
+ * @returns {{ archivos: Array, excluidos: number, lenguajesExcluidos: string[] }}
+ */
+function filtrarReglasPorStack(archivos, stackDetectado) {
+  const PREFIJO = 'reglas/lenguajes/';
+  const excluidos = [];
+  const lenguajesExcluidos = new Set();
+
+  const filtrados = archivos.filter(archivo => {
+    const ruta = archivo.rutaRelativa || '';
+    if (!ruta.startsWith(PREFIJO)) {
+      return true; // no es regla de lenguaje → conservar
+    }
+
+    // Extraer lenguaje: "reglas/lenguajes/LANG/archivo.md"
+    const resto = ruta.slice(PREFIJO.length);
+    const lang = resto.split('/')[0];
+
+    if (!LENGUAJES_CON_REGLAS.has(lang) || stackDetectado.has(lang)) {
+      return true; // lenguaje detectado o desconocido → conservar
+    }
+
+    excluidos.push(ruta);
+    lenguajesExcluidos.add(lang);
+    return false;
+  });
+
+  return {
+    archivos: filtrados,
+    excluidos: excluidos.length,
+    lenguajesExcluidos: [...lenguajesExcluidos].sort(),
+  };
+}
+
+// ─── Helpers privados ────────────────────────────────────────────────────────
+
+function _tieneIndicador(dir, indicadores) {
+  // Archivos exactos
+  if (indicadores.archivos) {
+    for (const archivo of indicadores.archivos) {
+      if (fs.existsSync(path.join(dir, archivo))) {
+        return true;
+      }
+    }
+  }
+
+  // Directorios
+  if (indicadores.directorios) {
+    for (const subdir of indicadores.directorios) {
+      if (fs.existsSync(path.join(dir, subdir))) {
+        return true;
+      }
+    }
+  }
+
+  // Extensiones en los 2 primeros niveles (escaneo rápido)
+  if (indicadores.extensiones) {
+    for (const ext of indicadores.extensiones) {
+      if (_tieneExtension(dir, ext, 2)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function _tieneExtension(dir, ext, profMax, prof = 0) {
+  if (prof > profMax) return false;
+
+  let entradas;
+  try {
+    entradas = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+
+  const IGNORAR = new Set([
+    'node_modules', 'vendor', '.git', 'dist', 'build',
+    '__pycache__', '.venv', 'venv', '.swl-backup',
+  ]);
+
+  for (const entrada of entradas) {
+    if (entrada.name.startsWith('.') || IGNORAR.has(entrada.name)) continue;
+
+    if (!entrada.isDirectory() && entrada.name.endsWith(ext)) {
+      return true;
+    }
+
+    if (entrada.isDirectory()) {
+      if (_tieneExtension(path.join(dir, entrada.name), ext, profMax, prof + 1)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+module.exports = { detectarStack, filtrarReglasPorStack, LENGUAJES_CONOCIDOS };

package/scripts/lib/diary-entry.js

@@ -0,0 +1,234 @@
+'use strict';
+
+/**
+ * diary-entry.js
+ *
+ * Diario estructurado por sesión. Captura accomplishments, decisiones,
+ * challenges y aprendizajes clave en formato consumible por `/swl:aprender`.
+ *
+ * Patrón adaptado de `temp/cass_memory_system-main/src/diary.ts`. Diferencias:
+ *   - Zero-deps (sin zod). Validación manual.
+ *   - Compatible con sistema SWL existente (sessionId, sources como instintos).
+ *   - Markdown-renderable para humanos + JSON para máquinas.
+ *
+ * Modelo:
+ *   - Una entrada de diario = una sesión de trabajo.
+ *   - Vive en `.planning/sessions/diary/{id}.json`.
+ *   - Es input para `/swl:aprender` (genera entradas en APRENDIZAJES.md
+ *     o instintos cuando aplique).
+ *   - NO sustituye a sessions/search-index.json — la sesión cruda sigue
+ *     siendo la fuente de verdad. Diary es derivado estructurado.
+ *
+ * @module scripts/lib/diary-entry
+ */
+
+const crypto = require('crypto');
+
+// ── constantes ────────────────────────────────────────────────────────────────
+
+const REQUIRED_FIELDS = ['id', 'sessionId', 'date', 'createdAt'];
+const ARRAY_FIELDS = ['accomplishments', 'decisions', 'challenges', 'keyLearnings', 'tags'];
+const MAX_ITEM_LENGTH = 500;
+const MAX_ITEMS_PER_FIELD = 20;
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function todayDate() {
+  return nowIso().slice(0, 10);
+}
+
+function shortHash(input) {
+  return crypto.createHash('sha1').update(input).digest('hex').slice(0, 8);
+}
+
+function generateDiaryId(sessionId, date) {
+  const d = (date || todayDate()).replace(/-/g, '');
+  const h = shortHash(`${sessionId}|${date || todayDate()}|${Date.now()}`);
+  return `diary-${d}-${h}`;
+}
+
+function clampString(s, max) {
+  if (typeof s !== 'string') return '';
+  const t = s.trim();
+  if (t.length <= max) return t;
+  return t.slice(0, max - 3) + '...';
+}
+
+// ── API pública ───────────────────────────────────────────────────────────────
+
+/**
+ * Crea una entrada de diario nueva. Pure (devuelve objeto).
+ *
+ * @param {object} params
+ * @param {string} params.sessionId  - obligatorio
+ * @param {string} [params.agent]    - agente principal (opcional)
+ * @param {string} [params.date]     - YYYY-MM-DD; default hoy
+ * @param {string} [params.startTime]- ISO; default ahora
+ * @returns {object} entry
+ */
+function createDiary({ sessionId, agent, date, startTime } = {}) {
+  if (!sessionId || typeof sessionId !== 'string') {
+    throw new TypeError('sessionId es obligatorio (string)');
+  }
+  const finalDate = date || todayDate();
+  return {
+    id: generateDiaryId(sessionId, finalDate),
+    sessionId,
+    agent: agent || null,
+    date: finalDate,
+    startTime: startTime || nowIso(),
+    endTime: null,
+    accomplishments: [],
+    decisions: [],
+    challenges: [],
+    keyLearnings: [],
+    tags: [],
+    sourceAgents: [],
+    createdAt: nowIso(),
+  };
+}
+
+function _addItem(entry, field, text) {
+  if (!ARRAY_FIELDS.includes(field)) {
+    throw new Error(`Campo desconocido: ${field}`);
+  }
+  const trimmed = clampString(text, MAX_ITEM_LENGTH);
+  if (!trimmed) return entry;  // ignorar vacíos
+  const next = { ...entry, [field]: [...(entry[field] || [])] };
+  if (next[field].length >= MAX_ITEMS_PER_FIELD) return entry;
+  if (next[field].includes(trimmed)) return entry;  // dedup exacto
+  next[field].push(trimmed);
+  return next;
+}
+
+const addAccomplishment = (e, t) => _addItem(e, 'accomplishments', t);
+const addDecision       = (e, t) => _addItem(e, 'decisions', t);
+const addChallenge      = (e, t) => _addItem(e, 'challenges', t);
+const addLearning       = (e, t) => _addItem(e, 'keyLearnings', t);
+const addTag            = (e, t) => _addItem(e, 'tags', t);
+
+/**
+ * Adjunta un agente que contribuyó (mantiene unicidad). Pure.
+ */
+function addSourceAgent(entry, agentName) {
+  if (!agentName || typeof agentName !== 'string') return entry;
+  const set = new Set(entry.sourceAgents || []);
+  set.add(agentName);
+  return { ...entry, sourceAgents: [...set] };
+}
+
+/**
+ * Marca el cierre de la sesión. Pure.
+ */
+function closeDiary(entry, endTime) {
+  return { ...entry, endTime: endTime || nowIso() };
+}
+
+/**
+ * Valida estructura de la entrada.
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+function validateDiary(entry) {
+  const errors = [];
+  if (!entry || typeof entry !== 'object') {
+    return { valid: false, errors: ['entry no es objeto'] };
+  }
+  for (const f of REQUIRED_FIELDS) {
+    if (!entry[f]) errors.push(`falta campo obligatorio: ${f}`);
+  }
+  for (const f of ARRAY_FIELDS) {
+    if (entry[f] != null && !Array.isArray(entry[f])) {
+      errors.push(`${f} debe ser array`);
+    }
+    if (Array.isArray(entry[f]) && entry[f].length > MAX_ITEMS_PER_FIELD) {
+      errors.push(`${f} excede el máximo de ${MAX_ITEMS_PER_FIELD} items`);
+    }
+  }
+  if (entry.date && !/^\d{4}-\d{2}-\d{2}$/.test(entry.date)) {
+    errors.push('date debe ser YYYY-MM-DD');
+  }
+  if (entry.id && !/^diary-\d{8}-[a-f0-9]+$/.test(entry.id)) {
+    errors.push('id debe ser diary-YYYYMMDD-{hash}');
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Serializa a JSON pretty (string).
+ */
+function serializeDiary(entry) {
+  return JSON.stringify(entry, null, 2);
+}
+
+/**
+ * Parsea desde JSON. Lanza si está malformado.
+ */
+function parseDiary(jsonText) {
+  const obj = JSON.parse(jsonText);
+  const { valid, errors } = validateDiary(obj);
+  if (!valid) throw new Error(`Diary inválido: ${errors.join('; ')}`);
+  return obj;
+}
+
+/**
+ * Convierte a Markdown legible para humanos. NO se persiste — es solo
+ * presentación. La fuente de verdad es el JSON.
+ */
+function toMarkdown(entry) {
+  const lines = [];
+  lines.push(`# Diary ${entry.id}`);
+  lines.push('');
+  lines.push(`**Sesión**: ${entry.sessionId}`);
+  if (entry.agent) lines.push(`**Agente principal**: ${entry.agent}`);
+  lines.push(`**Fecha**: ${entry.date}`);
+  if (entry.startTime) lines.push(`**Inicio**: ${entry.startTime}`);
+  if (entry.endTime) lines.push(`**Fin**: ${entry.endTime}`);
+  if (entry.tags && entry.tags.length) lines.push(`**Tags**: ${entry.tags.join(', ')}`);
+  lines.push('');
+
+  const sections = [
+    ['Logros', entry.accomplishments],
+    ['Decisiones', entry.decisions],
+    ['Challenges', entry.challenges],
+    ['Aprendizajes clave', entry.keyLearnings],
+  ];
+  for (const [titulo, items] of sections) {
+    if (!items || !items.length) continue;
+    lines.push(`## ${titulo}`);
+    lines.push('');
+    for (const item of items) lines.push(`- ${item}`);
+    lines.push('');
+  }
+
+  if (entry.sourceAgents && entry.sourceAgents.length) {
+    lines.push(`---`);
+    lines.push(`*Agentes que contribuyeron: ${entry.sourceAgents.join(', ')}*`);
+  }
+  return lines.join('\n');
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+
+module.exports = {
+  createDiary,
+  addAccomplishment,
+  addDecision,
+  addChallenge,
+  addLearning,
+  addTag,
+  addSourceAgent,
+  closeDiary,
+  validateDiary,
+  serializeDiary,
+  parseDiary,
+  toMarkdown,
+  generateDiaryId,
+  REQUIRED_FIELDS,
+  ARRAY_FIELDS,
+  MAX_ITEM_LENGTH,
+  MAX_ITEMS_PER_FIELD,
+};