@saulwade/swl-ses 1.0.0

package/scripts/lib/gestor-componentes.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { obtenerRuntime, calcularRutas } = require('./detectar-runtime');
+const { cargarEstado, guardarEstado } = require('./estado');
+const { resolverFuente } = require('./resolver-externo');
+const { validarRuta } = require('./seguridad');
+
+/**
+ * Lista componentes instalados de un tipo
+ */
+function listarComponentes(tipo, opciones = {}) {
+  const target = opciones.target || 'claude';
+  const esGlobal = opciones.global || false;
+  obtenerRuntime(target); // Valida que el target existe
+  const rutas = calcularRutas(target, { global: esGlobal });
+
+  const dir = tipo === 'skills' ? rutas.habilidades : rutas.agentes;
+  if (!dir || !fs.existsSync(dir)) {
+    return { componentes: [], total: 0 };
+  }
+
+  const componentes = [];
+  const entradas = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entrada of entradas) {
+    if (entrada.name.startsWith('.')) continue;
+
+    if (tipo === 'skills') {
+      if (!entrada.isDirectory()) continue;
+      const skillMd = path.join(dir, entrada.name, 'SKILL.md');
+      const existe = fs.existsSync(skillMd);
+      componentes.push({
+        nombre: entrada.name,
+        tipo: 'skill',
+        ruta: path.join(dir, entrada.name),
+        valido: existe,
+        fuente: 'sistema',
+      });
+    } else {
+      if (!entrada.isFile() || !entrada.name.endsWith('.md')) continue;
+      componentes.push({
+        nombre: entrada.name.replace('.md', ''),
+        tipo: 'agente',
+        ruta: path.join(dir, entrada.name),
+        valido: true,
+        fuente: 'sistema',
+      });
+    }
+  }
+
+  // Marcar externos desde el estado
+  const estado = cargarEstado(rutas.base);
+  if (estado && estado.componentesExternos) {
+    for (const ext of estado.componentesExternos) {
+      const comp = componentes.find(c => c.nombre === ext.nombre && ext.tipo === tipo);
+      if (comp) {
+        comp.fuente = 'externo';
+        comp.urlFuente = ext.fuente;
+        comp.fechaInstalacion = ext.fecha;
+      }
+    }
+  }
+
+  return { componentes, total: componentes.length };
+}
+
+/**
+ * Agrega un componente desde fuente externa
+ */
+function agregarComponente(tipo, fuente, opciones = {}) {
+  const target = opciones.target || 'claude';
+  const esGlobal = opciones.global || false;
+  const force = opciones.force || false;
+  obtenerRuntime(target); // Valida que el target existe
+  const rutas = calcularRutas(target, { global: esGlobal });
+
+  const dir = tipo === 'skills' ? rutas.habilidades : rutas.agentes;
+  if (!dir) {
+    throw new Error(`Target "${target}" no soporta ${tipo}`);
+  }
+
+  // Resolver fuente
+  const resultado = resolverFuente(fuente, {
+    tipo: tipo === 'skills' ? 'skills' : 'agents',
+    nombre: opciones.nombre,
+    cacheDir: opciones.cacheDir,
+  });
+
+  const instalados = [];
+  const advertencias = [];
+
+  for (const archivo of resultado.archivos) {
+    const destino = tipo === 'skills'
+      ? path.join(dir, archivo.nombre)
+      : path.join(dir, archivo.nombre + '.md');
+
+    // Validar ruta
+    validarRuta(dir, archivo.nombre);
+
+    // Verificar colisión
+    if (fs.existsSync(destino) && !force) {
+      advertencias.push(`"${archivo.nombre}" ya existe. Usa --force para sobreescribir.`);
+      continue;
+    }
+
+    // Crear directorio destino
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    if (archivo.esDirectorio) {
+      // Copiar directorio de skill
+      if (archivo.contenidoDir) {
+        // Desde Git: reconstruir desde contenido leído
+        escribirDirectorioRecursivo(destino, archivo.contenidoDir);
+      } else {
+        // Desde local: copiar directamente
+        copiarDirectorioRecursivo(archivo.ruta, destino);
+      }
+    } else {
+      // Copiar archivo de agente
+      fs.writeFileSync(destino, archivo.contenido, 'utf-8');
+    }
+
+    instalados.push(archivo.nombre);
+    console.log(`  + ${archivo.nombre}`);
+  }
+
+  // Registrar en estado
+  const estado = cargarEstado(rutas.base) || {};
+  if (!estado.componentesExternos) {
+    estado.componentesExternos = [];
+  }
+
+  for (const nombre of instalados) {
+    // Remover entrada previa si existe
+    estado.componentesExternos = estado.componentesExternos.filter(
+      c => !(c.nombre === nombre && c.tipo === tipo)
+    );
+    estado.componentesExternos.push({
+      nombre,
+      tipo,
+      fuente: fuente,
+      fecha: new Date().toISOString(),
+    });
+  }
+
+  if (estado.version) {
+    guardarEstado(estado, rutas.base);
+  }
+
+  return { instalados, advertencias };
+}
+
+/**
+ * Remueve un componente individual
+ */
+function removerComponente(tipo, nombre, opciones = {}) {
+  const target = opciones.target || 'claude';
+  const esGlobal = opciones.global || false;
+  obtenerRuntime(target); // Valida que el target existe
+  const rutas = calcularRutas(target, { global: esGlobal });
+
+  const dir = tipo === 'skills' ? rutas.habilidades : rutas.agentes;
+  if (!dir) {
+    throw new Error(`Target "${target}" no soporta ${tipo}`);
+  }
+
+  const ruta = tipo === 'skills'
+    ? path.join(dir, nombre)
+    : path.join(dir, nombre.endsWith('.md') ? nombre : nombre + '.md');
+
+  if (!fs.existsSync(ruta)) {
+    throw new Error(`${tipo === 'skills' ? 'Skill' : 'Agente'} "${nombre}" no encontrado en ${dir}`);
+  }
+
+  const stat = fs.statSync(ruta);
+  if (stat.isDirectory()) {
+    fs.rmSync(ruta, { recursive: true });
+  } else {
+    fs.unlinkSync(ruta);
+  }
+
+  console.log(`  - ${nombre} eliminado`);
+
+  // Actualizar estado
+  const estado = cargarEstado(rutas.base);
+  if (estado) {
+    if (estado.componentesExternos) {
+      estado.componentesExternos = estado.componentesExternos.filter(
+        c => !(c.nombre === nombre && c.tipo === tipo)
+      );
+    }
+    if (estado.archivosInstalados) {
+      estado.archivosInstalados = estado.archivosInstalados.filter(
+        a => !a.destino.includes(nombre)
+      );
+    }
+    guardarEstado(estado, rutas.base);
+  }
+
+  return { eliminado: true };
+}
+
+// --- Helpers ---
+
+function copiarDirectorioRecursivo(origen, destino) {
+  if (!fs.existsSync(destino)) {
+    fs.mkdirSync(destino, { recursive: true });
+  }
+  const entradas = fs.readdirSync(origen, { withFileTypes: true });
+  for (const entrada of entradas) {
+    const src = path.join(origen, entrada.name);
+    const dst = path.join(destino, entrada.name);
+    if (entrada.isDirectory()) {
+      copiarDirectorioRecursivo(src, dst);
+    } else {
+      fs.copyFileSync(src, dst);
+    }
+  }
+}
+
+function escribirDirectorioRecursivo(destino, contenidoDir) {
+  if (!fs.existsSync(destino)) {
+    fs.mkdirSync(destino, { recursive: true });
+  }
+  for (const [nombre, entrada] of Object.entries(contenidoDir)) {
+    const rutaArchivo = path.join(destino, nombre);
+    if (entrada.tipo === 'dir') {
+      escribirDirectorioRecursivo(rutaArchivo, entrada.contenido);
+    } else {
+      fs.writeFileSync(rutaArchivo, entrada.contenido, 'utf-8');
+    }
+  }
+}
+
+module.exports = {
+  listarComponentes,
+  agregarComponente,
+  removerComponente,
+};

package/scripts/lib/gitignore-manifest.js

@@ -0,0 +1,305 @@
+"use strict";
+
+/**
+ * gitignore-manifest.js
+ *
+ * Dos responsabilidades:
+ *   1. Gestionar la sección swl-ses en el .gitignore del proyecto destino.
+ *   2. Leer/escribir el manifest .swl-ses (declara target y profile del proyecto).
+ *
+ * Filosofía: swl-ses es tooling de desarrollo — no forma parte del proyecto.
+ * Todo lo que instala o genera en runtime se ignora en git (framework, hooks,
+ * métricas, sesiones, aprendizajes, trazas, instintos).
+ *
+ * Solo se commitean: CLAUDE.md, .claude/settings.json, y las plantillas de
+ * .planning/ que el equipo edita (PROYECTO.md, REQUISITOS.md, etc.).
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const MARKER_INICIO = "# [swl-ses:inicio]";
+const MARKER_FIN = "# [swl-ses:fin]";
+const MANIFEST_FILE = ".swl-ses";
+
+// Entradas que siempre se agregan (claude/openclaude comparten .claude/)
+//
+// Filosofía: swl-ses es tooling de desarrollo (como node_modules/). Los archivos
+// que instala o genera en runtime NO forman parte del proyecto y no se commitean.
+// Solo se commitean: .swl-ses (manifest), CLAUDE.md, .claude/settings.json,
+// y las plantillas de .planning/ (PROYECTO.md, REQUISITOS.md, HOJA-RUTA.md,
+// ESTADO.md, research/).
+const ENTRADAS_BASE = [
+  // ── Framework (instalado por swl-ses) ──────────────────────────────
+  ".claude/agents/",
+  ".claude/skills/",
+  ".claude/commands/",
+  ".claude/rules/",
+  ".claude/.swl-install-state.json",
+  // Permisos locales de Claude Code (convención .local.json = scope personal
+  // con paths absolutos de la máquina — no propagar a otros clones)
+  ".claude/settings.local.json",
+  "hooks/",
+
+  // ── Manifest (opcional: commitear si el equipo quiere declarar target/profile) ──
+  ".swl-ses",
+
+  // ── Runtime: archivos generados automáticamente por hooks ──────────
+  // Aprendizajes, métricas, compactación (extraccion-aprendizajes, tracking-costos, context-compressor)
+  ".planning/APRENDIZAJES.md",
+  ".planning/METRICAS.md",
+  ".planning/COMPACTACION.md",
+  ".planning/REPORTE-GRAFO.md",
+
+  // Audit trail (audit-trail.js, merkle-audit.js)
+  ".planning/*.jsonl",
+
+  // Sesiones, comunicación entre agentes, trazas, runs (session-store, agent-comms, otlp-exporter, run-log)
+  ".planning/sessions/",
+  ".planning/comms/",
+  ".planning/traces/",
+  ".planning/runs/",
+  ".planning/backups/",
+
+  // Estado de ejecución multi-agente (execution-state.js)
+  ".planning/execution-state.json",
+
+  // Ciclo AGP: telemetría, nudges, locks y dirty-bits escritos por hooks
+  // (metricas-evolucion, nudge-tracker, drift-detector, auto-evolucion,
+  // singleton-guard, actualizar-perfil-usuario). Output de runtime, no
+  // artefactos del proyecto usuario.
+  ".planning/evolucion/",
+  ".planning/auto-evolucion/",
+  ".planning/locks/",
+  ".planning/perfil-usuario/",
+
+  // Instintos modificados automáticamente por hooks (degradacion-instintos.js)
+  "instintos/",
+
+  // Base de datos de uso
+  "usage.db",
+];
+
+// Entradas adicionales por runtime (se agregan cuando install usa ese target)
+const ENTRADAS_POR_RUNTIME = {
+  claude: [], // ya cubiertas por ENTRADAS_BASE
+  openclaude: [], // comparte .claude/ con claude
+  copilot: [
+    ".github/agents/",
+    ".github/skills/",
+    ".github/commands/",
+    ".github/rules/",
+    ".github/.swl-install-state.json",
+  ],
+  opencode: [
+    ".opencode/agents/",
+    ".opencode/skills/",
+    ".opencode/commands/",
+    ".opencode/rules/",
+    ".opencode/.swl-install-state.json",
+  ],
+  codex: [
+    ".codex/agents/",
+    ".codex/skills/",
+    ".codex/commands/",
+    ".codex/rules/",
+    ".codex/.swl-install-state.json",
+  ],
+  gemini: [
+    ".gemini/agents/",
+    ".gemini/skills/",
+    ".gemini/commands/",
+    ".gemini/rules/",
+    ".gemini/.swl-install-state.json",
+  ],
+};
+
+// ── Gitignore ─────────────────────────────────────────────────────────────
+
+/**
+ * Actualiza (o crea) el .gitignore del proyecto con la sección swl-ses.
+ * Usa marcadores para reemplazar la sección si ya existe sin duplicar nada.
+ * No toca entradas que el usuario puso fuera de los marcadores.
+ *
+ * @param {string} cwd          Directorio raíz del proyecto
+ * @param {string[]} extras     Entradas adicionales (ej. para runtime no-claude)
+ * @returns {string}            Ruta al .gitignore
+ */
+function actualizarGitignore(cwd, extras = []) {
+  const gitignorePath = path.join(cwd, ".gitignore");
+  let existente = fs.existsSync(gitignorePath)
+    ? fs.readFileSync(gitignorePath, "utf-8")
+    : "";
+
+  // Eliminar sección swl-ses anterior si existe
+  const reSeccion = new RegExp(
+    `\\n?${escapeRegex(MARKER_INICIO)}[\\s\\S]*?${escapeRegex(MARKER_FIN)}\\n?`,
+    "g",
+  );
+  existente = existente.replace(reSeccion, "");
+
+  // Construir lista de entradas final (base + extras), deduplicada
+  const todasLasEntradas = [...new Set([...ENTRADAS_BASE, ...extras])];
+
+  // No agregar entradas que el usuario ya tenga fuera de la sección
+  const lineasExistentes = new Set(
+    existente
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean),
+  );
+  const entradasFiltradas = todasLasEntradas.filter(
+    (e) => !lineasExistentes.has(e),
+  );
+
+  // Si todas las entradas ya existen fuera de la sección, igual creamos la
+  // sección marcada para gestionarla en el futuro (actualizaciones, etc.)
+  const entradas =
+    entradasFiltradas.length > 0 ? todasLasEntradas : todasLasEntradas;
+
+  const seccion = [
+    "",
+    MARKER_INICIO,
+    "# swl-ses: tooling de desarrollo — no forma parte del proyecto.",
+    "# Framework, runtime y métricas generadas automáticamente.",
+    "# Para reinstalar: npx swl-ses@latest install",
+    ...entradas,
+    MARKER_FIN,
+    "",
+  ].join("\n");
+
+  fs.writeFileSync(gitignorePath, existente.trimEnd() + seccion, "utf-8");
+  return gitignorePath;
+}
+
+/**
+ * Devuelve las entradas gitignore específicas para un runtime dado.
+ * Se suman a las ENTRADAS_BASE que siempre se agregan.
+ *
+ * @param {string} runtimeId  Id del runtime (claude, copilot, opencode, …)
+ * @returns {string[]}
+ */
+function entradasParaRuntime(runtimeId) {
+  return ENTRADAS_POR_RUNTIME[runtimeId] || [];
+}
+
+// ── Manifest (.swl-ses) ───────────────────────────────────────────────────
+
+/**
+ * Lee el manifest .swl-ses del directorio indicado.
+ * Devuelve null si no existe o tiene JSON inválido.
+ *
+ * @param {string} cwd
+ * @returns {{ target: string, profile: string, version: string } | null}
+ */
+function leerManifest(cwd) {
+  const manifestPath = path.join(cwd, MANIFEST_FILE);
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Escribe o actualiza el manifest .swl-ses.
+ * Preserva campos existentes no presentes en data (merge parcial).
+ *
+ * @param {string} cwd
+ * @param {{ target?: string, profile?: string, version?: string }} data
+ * @returns {string}  Ruta al manifest
+ */
+function escribirManifest(cwd, data) {
+  const manifestPath = path.join(cwd, MANIFEST_FILE);
+  const existente = leerManifest(cwd) || {};
+  const manifest = { ...existente, ...data };
+  fs.writeFileSync(
+    manifestPath,
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8",
+  );
+  return manifestPath;
+}
+
+// ── Git untrack ──────────────────────────────────────────────────────────
+
+/**
+ * Detecta archivos instalados por swl-ses que están tracked en git y los
+ * quita del índice con `git rm --cached`. NO elimina los archivos del disco.
+ *
+ * Esto resuelve el caso donde el usuario commiteó archivos swl-ses antes de
+ * que el .gitignore los cubriera. Una vez en .gitignore + fuera del índice,
+ * git deja de mostrarlos como modificados.
+ *
+ * @param {string} cwd       Directorio raíz del proyecto
+ * @param {string[]} extras  Entradas gitignore adicionales (por runtime)
+ * @returns {{ eliminados: number, archivos: string[] }}
+ */
+function limpiarTracked(cwd, extras = []) {
+  const { execSync, execFileSync } = require("child_process");
+  const resultado = { eliminados: 0, archivos: [] };
+
+  // Verificar que estamos en un repo git
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+  } catch {
+    return resultado; // No es repo git, nada que hacer
+  }
+
+  // Obtener todas las entradas gitignore de swl-ses (directorios y archivos)
+  const entradas = [...new Set([...ENTRADAS_BASE, ...extras])];
+
+  for (const entrada of entradas) {
+    try {
+      // Sin shell: pathspec y rutas desde git pueden contener comillas, $(), etc.;
+      // execFileSync pasa argv literal a git (mitiga inyección de comandos).
+      const tieneGlob = entrada.includes("*");
+      const pathspec = tieneGlob ? entrada : entrada.replace(/\/$/, "");
+      const archivosTracked = execFileSync(
+        "git",
+        ["ls-files", "--cached", "--", pathspec],
+        { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+      ).trim();
+
+      if (!archivosTracked) continue;
+
+      const lista = archivosTracked.split("\n").filter(Boolean);
+      if (lista.length === 0) continue;
+
+      // Quitar del índice uno por uno (--cached = solo del índice, no del disco)
+      for (const archivo of lista) {
+        try {
+          execFileSync("git", ["rm", "--cached", "-q", "--", archivo], {
+            cwd,
+            stdio: "pipe",
+          });
+        } catch {
+          /* archivo ya fuera del índice */
+        }
+      }
+
+      resultado.eliminados += lista.length;
+      resultado.archivos.push(...lista);
+    } catch {
+      // Si falla (archivo no existe en índice, etc.), continuar
+    }
+  }
+
+  return resultado;
+}
+
+// ── Utilidades ────────────────────────────────────────────────────────────
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+module.exports = {
+  actualizarGitignore,
+  entradasParaRuntime,
+  limpiarTracked,
+  leerManifest,
+  escribirManifest,
+  MANIFEST_FILE,
+};