@saulwade/swl-ses 1.0.0

package/bin/lib/bot-discovery.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * Descubrimiento de proyectos Claude Code desde ~/.claude/projects/
+ *
+ * Escanea los directorios de proyectos del harness de Claude Code,
+ * extrae el `cwd` del .jsonl más reciente de cada proyecto y deriva
+ * el nombre del proyecto con path.basename(cwd).
+ *
+ * @module bin/lib/bot-discovery
+ */
+
+const fs   = require('node:fs');
+const path = require('node:path');
+const os   = require('node:os');
+
+// Directorio estándar de proyectos de Claude Code
+const DIR_PROYECTOS = path.join(os.homedir(), '.claude', 'projects');
+
+/**
+ * Extrae el valor `cwd` de una línea del archivo .jsonl de sesión.
+ * Busca en el formato de sesiones de Claude Code.
+ *
+ * @param {string} linea - Una línea JSON del archivo .jsonl.
+ * @returns {string|null} El cwd encontrado o null.
+ */
+function _extraerCwd(linea) {
+  try {
+    const obj = JSON.parse(linea);
+    // Formato de sesión Claude Code: { cwd: '...' }
+    if (obj && typeof obj.cwd === 'string' && obj.cwd.trim()) {
+      return obj.cwd.trim();
+    }
+  } catch (_) {
+    // Ignorar líneas malformadas
+  }
+  return null;
+}
+
+/**
+ * Busca el cwd en un archivo .jsonl leyendo las primeras N líneas.
+ *
+ * @param {string} rutaJsonl - Ruta al archivo .jsonl de sesión.
+ * @returns {string|null} El cwd encontrado o null.
+ */
+function _cwdDeJsonl(rutaJsonl) {
+  try {
+    const contenido = fs.readFileSync(rutaJsonl, 'utf8');
+    const lineas = contenido.split('\n');
+    for (const linea of lineas) {
+      const recortada = linea.trim();
+      if (!recortada) continue;
+      const cwd = _extraerCwd(recortada);
+      if (cwd) return cwd;
+    }
+  } catch (_) {
+    // Archivo ilegible: ignorar
+  }
+  return null;
+}
+
+/**
+ * Obtiene el archivo .jsonl más reciente en un directorio de proyecto.
+ *
+ * @param {string} dirProyecto - Directorio del proyecto Claude Code.
+ * @returns {{ ruta: string, mtime: number }|null} El jsonl más reciente o null.
+ */
+function _jsonlMasReciente(dirProyecto) {
+  try {
+    const archivos = fs.readdirSync(dirProyecto);
+    let mejor = null;
+
+    for (const archivo of archivos) {
+      if (!archivo.endsWith('.jsonl')) continue;
+      const ruta = path.join(dirProyecto, archivo);
+      try {
+        const stat = fs.statSync(ruta);
+        if (!mejor || stat.mtimeMs > mejor.mtime) {
+          mejor = { ruta, mtime: stat.mtimeMs };
+        }
+      } catch (_) {
+        // Si no se puede leer el stat, saltar
+      }
+    }
+
+    return mejor;
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Descubre proyectos activos de Claude Code.
+ *
+ * Escanea ~/.claude/projects/, lee el .jsonl más reciente de cada subdirectorio
+ * y extrae el cwd para derivar el nombre del proyecto.
+ *
+ * @returns {Array<{ nombre: string, cwd: string, mtime: number }>}
+ *   Lista de proyectos ordenada por mtime descendente (más reciente primero).
+ */
+function descubrirProyectos() {
+  if (!fs.existsSync(DIR_PROYECTOS)) return [];
+
+  const proyectos = [];
+
+  let entradas;
+  try {
+    entradas = fs.readdirSync(DIR_PROYECTOS);
+  } catch (_) {
+    return [];
+  }
+
+  for (const entrada of entradas) {
+    const dirProyecto = path.join(DIR_PROYECTOS, entrada);
+    try {
+      const stat = fs.statSync(dirProyecto);
+      if (!stat.isDirectory()) continue;
+    } catch (_) {
+      continue;
+    }
+
+    const jsonlInfo = _jsonlMasReciente(dirProyecto);
+    if (!jsonlInfo) continue;
+
+    const cwd = _cwdDeJsonl(jsonlInfo.ruta);
+    if (!cwd) continue;
+
+    const nombre = path.basename(cwd);
+    if (!nombre) continue;
+
+    proyectos.push({ nombre, cwd, mtime: jsonlInfo.mtime });
+  }
+
+  // Ordenar por mtime descendente
+  proyectos.sort((a, b) => b.mtime - a.mtime);
+
+  return proyectos;
+}
+
+/**
+ * Resuelve un proyecto a partir de un término de búsqueda.
+ *
+ * Estrategia: match exacto > match por prefijo > match por substring.
+ * Si hay ambigüedad retorna la lista de candidatos para pedir aclaración.
+ *
+ * @param {string} termino - Término de búsqueda ingresado por el usuario.
+ * @param {Array<{ nombre: string, cwd: string, mtime: number }>} [proyectos]
+ *   Lista de proyectos a buscar. Si se omite, llama a descubrirProyectos().
+ * @returns {{ proyecto: object|null, candidatos: object[], ambiguo: boolean }}
+ */
+function resolverProyecto(termino, proyectos) {
+  if (!proyectos) proyectos = descubrirProyectos();
+  const t = (termino || '').trim().toLowerCase();
+
+  if (!t) return { proyecto: null, candidatos: [], ambiguo: false };
+
+  // Match exacto (case-insensitive)
+  const exacto = proyectos.filter((p) => p.nombre.toLowerCase() === t);
+  if (exacto.length === 1) return { proyecto: exacto[0], candidatos: exacto, ambiguo: false };
+  if (exacto.length > 1)   return { proyecto: null, candidatos: exacto, ambiguo: true };
+
+  // Match por prefijo
+  const prefijo = proyectos.filter((p) => p.nombre.toLowerCase().startsWith(t));
+  if (prefijo.length === 1) return { proyecto: prefijo[0], candidatos: prefijo, ambiguo: false };
+  if (prefijo.length > 1)   return { proyecto: null, candidatos: prefijo, ambiguo: true };
+
+  // Match por substring
+  const substring = proyectos.filter((p) => p.nombre.toLowerCase().includes(t));
+  if (substring.length === 1) return { proyecto: substring[0], candidatos: substring, ambiguo: false };
+  if (substring.length > 1)   return { proyecto: null, candidatos: substring, ambiguo: true };
+
+  return { proyecto: null, candidatos: [], ambiguo: false };
+}
+
+module.exports = {
+  descubrirProyectos,
+  resolverProyecto,
+  DIR_PROYECTOS,
+  // Exportar para tests
+  _cwdDeJsonl,
+  _extraerCwd,
+};

package/bin/lib/bot-git.js

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * Wrappers git con whitelist estricta para el bot de Telegram.
+ *
+ * SEGURIDAD: Solo se permiten los subcomandos definidos en WHITELIST_GIT.
+ * Toda llamada a git usa child_process.execFileSync con array de argumentos
+ * (shell desactivado, args como array) y timeout de 10 segundos.
+ *
+ * @module bin/lib/bot-git
+ */
+
+const { execFileSync } = require('node:child_process');
+
+// Timeout máximo por llamada git (ms)
+const TIMEOUT_GIT_MS = 10_000;
+
+/**
+ * Subcomandos git permitidos. Cualquier otro subcomando es rechazado.
+ * Solo comandos de lectura — NUNCA escritura.
+ */
+const WHITELIST_GIT = new Set([
+  'rev-parse',
+  'status',
+  'log',
+  'diff',
+  'branch',
+]);
+
+/**
+ * Ejecuta un comando git en el directorio indicado.
+ *
+ * @param {string} cwd       - Directorio del proyecto (obtenido de discoverProyectos).
+ * @param {string[]} args    - Argumentos para git (primer elemento = subcomando).
+ * @returns {{ ok: boolean, salida: string, error?: string }}
+ */
+function ejecutarGit(cwd, args) {
+  if (!Array.isArray(args) || args.length === 0) {
+    return { ok: false, salida: '', error: 'args vacíos' };
+  }
+
+  const subcomando = args[0];
+
+  if (!WHITELIST_GIT.has(subcomando)) {
+    return {
+      ok: false,
+      salida: '',
+      error: `subcomando no permitido: ${subcomando}`,
+    };
+  }
+
+  try {
+    const salida = execFileSync('git', ['-C', cwd, ...args], {
+      timeout: TIMEOUT_GIT_MS,
+      encoding: 'utf8',
+      // shell desactivado — args como array previene inyección de comandos
+      shell: false,
+      // Ignorar stderr para comandos que escriben ahí en algunos OS
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return { ok: true, salida: salida || '' };
+  } catch (err) {
+    const msg = err.stdout || err.stderr || err.message || 'error desconocido';
+    return { ok: false, salida: '', error: String(msg).trim() };
+  }
+}
+
+/**
+ * Obtiene el estado de un proyecto git.
+ *
+ * Retorna: rama actual, estado corto (--branch) y último commit (--oneline).
+ *
+ * @param {string} cwd - Directorio del proyecto.
+ * @returns {{ ok: boolean, rama: string, estado: string, ultimoCommit: string, error?: string }}
+ */
+function obtenerEstado(cwd) {
+  const rama = ejecutarGit(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  const estado = ejecutarGit(cwd, ['status', '--short', '--branch']);
+  const ultimoCommit = ejecutarGit(cwd, ['log', '-1', '--format=%h %s']);
+
+  if (!rama.ok && !estado.ok) {
+    return {
+      ok: false,
+      rama: '',
+      estado: '',
+      ultimoCommit: '',
+      error: rama.error || estado.error,
+    };
+  }
+
+  return {
+    ok: true,
+    rama: (rama.salida || '').trim(),
+    estado: (estado.salida || '').trim(),
+    ultimoCommit: (ultimoCommit.salida || '').trim(),
+  };
+}
+
+/**
+ * Obtiene el log de commits de un proyecto.
+ *
+ * @param {string} cwd   - Directorio del proyecto.
+ * @param {number} n     - Número de commits. Máximo 25 (se aplica silenciosamente).
+ * @returns {{ ok: boolean, lineas: string[], error?: string }}
+ */
+function obtenerLog(cwd, n) {
+  const limite = Math.min(Math.max(1, Number(n) || 5), 25);
+  const resultado = ejecutarGit(cwd, ['log', `-${limite}`, '--format=%h %s']);
+
+  if (!resultado.ok) {
+    return { ok: false, lineas: [], error: resultado.error };
+  }
+
+  const lineas = resultado.salida.split('\n').filter(Boolean);
+  return { ok: true, lineas };
+}
+
+/**
+ * Obtiene el diff stat de staged y no-staged de un proyecto.
+ *
+ * @param {string} cwd - Directorio del proyecto.
+ * @returns {{ ok: boolean, diffNoStaged: string, diffStaged: string, error?: string }}
+ */
+function obtenerDiff(cwd) {
+  const noStaged = ejecutarGit(cwd, ['diff', '--stat']);
+  const staged   = ejecutarGit(cwd, ['diff', '--stat', '--staged']);
+
+  return {
+    ok: true,
+    diffNoStaged: (noStaged.salida || '').trim(),
+    diffStaged:   (staged.salida || '').trim(),
+  };
+}
+
+module.exports = {
+  ejecutarGit,
+  obtenerEstado,
+  obtenerLog,
+  obtenerDiff,
+  WHITELIST_GIT,
+  TIMEOUT_GIT_MS,
+};

package/bin/swl-ses.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const VERSION = require('../package.json').version;
+const NOMBRE = 'swl-ses';
+
+/**
+ * Extrae [major, minor, patch] de una versión semver. Ignora prerelease y build
+ * metadata (ej. "5.7.5-beta.1+abc"). Retorna null si el formato es inválido.
+ * Nunca produce NaN — si un componente no es numérico, retorna null directamente.
+ */
+function parseSemver(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(String(v));
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+/**
+ * Compara dos versiones semver core. Retorna 1 si a > b, -1 si a < b, 0 si iguales.
+ * Retorna null si alguna no es parseable — el caller debe manejar el null.
+ */
+function compararSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb) return null;
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] > pb[i] ? 1 : -1;
+  }
+  return 0;
+}
+
+/**
+ * Detecta si el CLI cacheado de npx es más viejo que la instalación SWL del usuario.
+ * El caso típico: el usuario instaló vN vía `@latest` pero `npx swl-ses` sigue
+ * apuntando a una versión cacheada anterior sin que lo sepa.
+ *
+ * Busca `.swl-install-state.json` en las ubicaciones conocidas (global ~/.claude,
+ * local .claude y variantes de otros runtimes) y compara `versionSistema`.
+ */
+function verificarCoherenciaVersion() {
+  try {
+    const candidatos = [
+      path.join(os.homedir(), '.claude', '.swl-install-state.json'),
+      path.join(process.cwd(), '.claude', '.swl-install-state.json'),
+      path.join(process.cwd(), '.github', '.swl-install-state.json'),
+      path.join(process.cwd(), '.codex', '.swl-install-state.json'),
+      path.join(process.cwd(), '.gemini', '.swl-install-state.json'),
+      path.join(process.cwd(), '.opencode', '.swl-install-state.json'),
+    ];
+
+    let versionMax = null;
+    for (const ruta of candidatos) {
+      if (!fs.existsSync(ruta)) continue;
+      try {
+        const estado = JSON.parse(fs.readFileSync(ruta, 'utf-8'));
+        const v = estado.versionSistema;
+        if (!parseSemver(v)) continue;
+        if (!versionMax || compararSemver(v, versionMax) > 0) versionMax = v;
+      } catch { /* silencioso — archivo corrupto no debe romper el CLI */ }
+    }
+
+    if (versionMax && compararSemver(versionMax, VERSION) === 1) {
+      process.stderr.write(
+        `\n[swl-ses] AVISO: CLI desactualizado — ejecutando v${VERSION}, pero tu instalación SWL es v${versionMax}.\n` +
+        `[swl-ses] npm tiene cacheada una versión vieja. Para usar la versión correcta:\n` +
+        `[swl-ses]   npx @saulwade/swl-ses@latest <comando>\n` +
+        `[swl-ses] O limpia la caché de npx:\n` +
+        `[swl-ses]   npx clear-npx-cache\n\n`
+      );
+    }
+  } catch { /* nunca bloquear el CLI por este check */ }
+}
+
+const COMANDOS = {
+  init: '../scripts/inicializar.js',
+  install: '../scripts/instalador.js',
+  doctor: '../scripts/doctor.js',
+  update: '../scripts/actualizar.js',
+  uninstall: '../scripts/desinstalar.js',
+  'check-update': '../scripts/check-update.js',
+  'install-git-hook': '../scripts/instalar-git-hook.js',
+};
+
+// Comandos con subcomandos (nivel 2)
+const SUBCOMANDOS = {
+  skills: '../scripts/comandos/skills.js',
+  agents: '../scripts/comandos/agents.js',
+  info: '../scripts/comandos/info.js',
+};
+
+const AYUDA = `
+${NOMBRE} v${VERSION} — Sistema de Ingeniería de Software SWL
+
+USO:
+  ${NOMBRE} <comando> [subcomando] [opciones]
+
+COMANDOS PRINCIPALES:
+  init                          Inicializa .planning/ y _userland/ en el proyecto actual
+  install                       Instala componentes. Sin flags: modo asistido interactivo.
+                                Con flags: modo directo (ver OPCIONES DE INSTALL).
+  doctor                        Diagnóstica problemas de instalación
+  update                        Actualiza componentes instalados
+  uninstall                     Desinstala componentes del runtime
+  check-update                  Fuerza consulta inmediata de nueva versión en npm (sin throttle)
+  install-git-hook [--force]    Instala pre-commit hook que avisa de nuevas versiones.
+                                Útil para CLIs que no son Claude Code (Codex, Copilot,
+                                Gemini, OpenCode) donde el hook UserPromptSubmit no aplica.
+  info    [--target <runtime>]  Muestra información del sistema instalado
+  help                          Muestra esta ayuda (alias de --help)
+  list    [--target <runtime>]  Lista todos los agentes y skills instalados
+
+GESTIÓN DE COMPONENTES:
+  skills list                   Lista skills instalados
+  skills add <fuente>           Agrega skill desde repo Git o path local
+  skills remove <nombre>        Remueve un skill individual
+  agents list                   Lista agentes instalados
+  agents add <fuente>           Agrega agente desde repo Git o path local
+  agents remove <nombre>        Remueve un agente individual
+
+OPCIONES DE INSTALL:
+  --target <runtime>     Runtime destino: claude|openclaude|copilot|opencode|codex|gemini (default: claude)
+  --profile <perfil>     Perfil: core|backend-python|backend-node|frontend-react|frontend-angular|
+                         fullstack-python-angular|fullstack-node-react|mobile|devops|completo (default: core)
+  --with <componentes>   Incluir componentes adicionales (separados por coma)
+  --without <comps>      Excluir componentes (separados por coma)
+  --global               Instalar en directorio global del runtime (~/.claude, etc.)
+  --local                Instalar en directorio local del proyecto (.claude/, etc.)
+  --dry-run              Mostrar plan sin aplicar cambios
+  --force                Sobreescribir archivos existentes sin confirmar
+  --all-langs            Instalar reglas de todos los lenguajes (omite detección automática de stack)
+  --no-claudemd          No modificar el CLAUDE.md del proyecto (solo aplica con --target claude).
+                         Por defecto el instalador crea o actualiza un bloque delimitado por
+                         <!-- SWL-BEGIN vX.Y.Z --> / <!-- SWL-END --> preservando el resto del archivo.
+
+OPCIONES DE SKILLS/AGENTS:
+  --skill <nombre>       Nombre del skill a extraer del repo (con skills add)
+  --agent <nombre>       Nombre del agente a extraer del repo (con agents add)
+  --target <runtime>     Runtime destino (default: claude)
+
+OPCIONES GENERALES:
+  --version, -v          Muestra la versión
+  --help, -h             Muestra esta ayuda
+
+EJEMPLOS:
+  ${NOMBRE} init
+  ${NOMBRE} install                                    (modo asistido — recomendado para primera vez)
+  ${NOMBRE} install --target claude --profile backend-python
+  ${NOMBRE} install --target openclaude --profile fullstack-python-angular
+  ${NOMBRE} install --target gemini --profile core
+  ${NOMBRE} install --target copilot --profile fullstack-node-react
+  ${NOMBRE} skills list --target claude
+  ${NOMBRE} skills add https://github.com/user/repo --skill mi-skill
+  ${NOMBRE} agents add ./path/local --agent mi-agente
+  ${NOMBRE} info --target claude
+  ${NOMBRE} doctor
+  ${NOMBRE} uninstall --target claude
+`;
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(AYUDA);
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(`${NOMBRE} v${VERSION}`);
+    process.exit(0);
+  }
+
+  verificarCoherenciaVersion();
+
+  const comando = args[0];
+
+  // Alias de primer nivel: help → --help, list → resumen de componentes
+  if (comando === 'help') {
+    console.log(AYUDA);
+    process.exit(0);
+  }
+
+  if (comando === 'list') {
+    const opciones = parsearOpciones(args.slice(1));
+    try {
+      const { listarComponentes } = require('../scripts/lib/gestor-componentes');
+      for (const tipo of ['agents', 'skills']) {
+        const resultado = listarComponentes(tipo, opciones);
+        const label = tipo === 'agents' ? 'Agentes' : 'Skills';
+        console.log(`\n${label} instalados (${resultado.total}):\n`);
+        if (resultado.total === 0) {
+          console.log('  (ninguno)');
+        } else {
+          for (const c of resultado.componentes) {
+            console.log(`  ${c.nombre}`);
+          }
+        }
+      }
+      console.log('');
+    } catch (err) {
+      console.error(`Error listando componentes: ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Comandos con subcomandos (skills, agents, info)
+  if (SUBCOMANDOS[comando]) {
+    const subcomando = args[1] && !args[1].startsWith('-') ? args[1] : null;
+    const restoArgs = subcomando ? args.slice(2) : args.slice(1);
+    const opciones = parsearOpciones(restoArgs);
+
+    try {
+      const modulo = require(SUBCOMANDOS[comando]);
+      const resultado = modulo(subcomando, opciones);
+      // Soportar módulos async (e.g. skills add con selector interactivo)
+      if (resultado && typeof resultado.then === 'function') {
+        resultado.catch(err => {
+          console.error(`Error ejecutando "${comando}${subcomando ? ' ' + subcomando : ''}": ${err.message}`);
+          if (opciones.verbose) console.error(err.stack);
+          process.exit(1);
+        });
+        return;
+      }
+    } catch (err) {
+      console.error(`Error ejecutando "${comando}${subcomando ? ' ' + subcomando : ''}": ${err.message}`);
+      if (opciones.verbose) {
+        console.error(err.stack);
+      }
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Comandos simples (init, install, doctor, update, uninstall)
+  if (!COMANDOS[comando]) {
+    console.error(`Error: Comando desconocido "${comando}"`);
+    console.error(`Ejecuta "${NOMBRE} --help" para ver los comandos disponibles.`);
+    process.exit(1);
+  }
+
+  const opciones = parsearOpciones(args.slice(1));
+
+  // Modo asistido: `install` sin flags → flujo interactivo
+  // (Si el usuario pasa cualquier flag relevante, se asume que sabe lo que hace.)
+  if (comando === 'install') {
+    const flagsIrrelevantesParaAsistido = ['verbose'];
+    const flagsEspecificados = Object.keys(opciones).filter(
+      k => k !== '_args' && !flagsIrrelevantesParaAsistido.includes(k)
+    );
+    if (flagsEspecificados.length === 0) {
+      try {
+        const asistido = require('../scripts/comandos/install-asistido');
+        asistido.main().catch(err => {
+          console.error(`Error ejecutando instalación asistida: ${err.message}`);
+          if (opciones.verbose) console.error(err.stack);
+          process.exit(1);
+        });
+        return;
+      } catch (err) {
+        console.error(`Error ejecutando "${comando}": ${err.message}`);
+        if (opciones.verbose) console.error(err.stack);
+        process.exit(1);
+      }
+    }
+  }
+
+  try {
+    const modulo = require(COMANDOS[comando]);
+    const resultado = modulo(opciones);
+    // Soportar módulos async (update, doctor con interactividad)
+    if (resultado && typeof resultado.then === 'function') {
+      resultado.catch(err => {
+        console.error(`Error ejecutando "${comando}": ${err.message}`);
+        if (opciones.verbose) console.error(err.stack);
+        process.exit(1);
+      });
+      return;
+    }
+  } catch (err) {
+    console.error(`Error ejecutando "${comando}": ${err.message}`);
+    if (opciones.verbose) {
+      console.error(err.stack);
+    }
+    process.exit(1);
+  }
+}
+
+function parsearOpciones(args) {
+  const opciones = { _args: [] };
+  let i = 0;
+
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg.startsWith('--')) {
+      const clave = arg.slice(2);
+      // Opciones booleanas
+      if (['global', 'local', 'dry-run', 'force', 'verbose', 'all', 'all-langs', 'no-claudemd'].includes(clave)) {
+        opciones[clave.replace(/-/g, '_')] = true;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        opciones[clave] = args[i + 1];
+        i++;
+      } else {
+        opciones[clave] = true;
+      }
+    } else if (arg.startsWith('-')) {
+      const clave = arg.slice(1);
+      if (clave === 'v') opciones.version = true;
+      else if (clave === 'h') opciones.help = true;
+    } else {
+      // Argumentos posicionales (fuente en skills add, nombre en skills remove)
+      opciones._args.push(arg);
+    }
+
+    i++;
+  }
+
+  return opciones;
+}
+
+main();