elsabro 2.0.0

package/bin/install.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const red = '\x1b[31m';
+const dim = '\x1b[2m';
+const bold = '\x1b[1m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasUninstall = args.includes('--uninstall') || args.includes('-u');
+const hasUpdate = args.includes('--update');
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+const banner = `
+${cyan}███████╗██╗     ███████╗ █████╗ ██████╗ ██████╗  ██████╗
+██╔════╝██║     ██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔═══██╗
+█████╗  ██║     ███████╗███████║██████╔╝██████╔╝██║   ██║
+██╔══╝  ██║     ╚════██║██╔══██║██╔══██╗██╔══██╗██║   ██║
+███████╗███████╗███████║██║  ██║██████╔╝██║  ██║╚██████╔╝
+╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝ ╚═════╝${reset}
+
+  ${bold}El Sabro${reset} ${dim}v${pkg.version}${reset}
+  Tu asistente AI para crear apps increíbles
+  Sin necesidad de saber programar.
+`;
+
+// Detect package manager used
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || '';
+  if (userAgent.includes('pnpm')) return 'pnpm';
+  if (userAgent.includes('bun')) return 'bun';
+  if (userAgent.includes('yarn')) return 'yarn';
+  return 'npm';
+}
+
+// Get global directory (validates all sources)
+function getGlobalDir(explicitDir = null) {
+  let targetDir = null;
+
+  if (explicitDir) {
+    targetDir = expandTilde(explicitDir);
+  } else if (process.env.CLAUDE_CONFIG_DIR) {
+    targetDir = expandTilde(process.env.CLAUDE_CONFIG_DIR);
+    // Validate env var path too (security: env vars can be manipulated)
+    validatePath(targetDir);
+  } else {
+    return path.join(os.homedir(), '.claude');
+  }
+
+  return targetDir;
+}
+
+// Expand ~ to home directory
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+// Validate path is safe (no path traversal)
+function validatePath(inputPath) {
+  if (!inputPath) return true;
+
+  // Check for path traversal BEFORE normalization (catches encoded attempts)
+  if (inputPath.includes('..')) {
+    console.error(`  ${red}✗${reset} Ruta inválida: no se permite '..'`);
+    process.exit(1);
+  }
+
+  // Resolve to absolute path and normalize
+  const resolved = path.resolve(inputPath);
+  const homeDir = os.homedir();
+  const cwd = process.cwd();
+
+  // Expanded blocklist for system directories
+  const suspicious = ['/etc', '/usr', '/bin', '/sbin', '/var', '/tmp', '/root', '/proc', '/sys', '/dev', '/boot'];
+
+  // If not under home or cwd, check against blocklist
+  if (!resolved.startsWith(homeDir) && !resolved.startsWith(cwd)) {
+    for (const pattern of suspicious) {
+      if (resolved === pattern || resolved.startsWith(pattern + '/')) {
+        console.error(`  ${red}✗${reset} Ruta inválida: no se permite instalar en ${pattern}`);
+        process.exit(1);
+      }
+    }
+  }
+
+  // Windows: check for system directories and UNC paths
+  if (process.platform === 'win32') {
+    // Block UNC paths
+    if (resolved.startsWith('\\\\') || resolved.startsWith('//')) {
+      console.error(`  ${red}✗${reset} Ruta inválida: UNC paths no permitidos`);
+      process.exit(1);
+    }
+
+    const winSuspicious = ['C:\\Windows', 'C:\\Program Files', 'C:\\System32'];
+    for (const pattern of winSuspicious) {
+      if (resolved.toLowerCase().startsWith(pattern.toLowerCase())) {
+        console.error(`  ${red}✗${reset} Ruta inválida: no se permite instalar en ${pattern}`);
+        process.exit(1);
+      }
+    }
+  }
+
+  return true;
+}
+
+// Get executable name for current platform
+function getExecutable(name) {
+  return process.platform === 'win32' ? `${name}.cmd` : name;
+}
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    const value = configDirArg.split('=')[1];
+    if (!value) {
+      console.error(`  ${yellow}--config-dir requires a non-empty path${reset}`);
+      process.exit(1);
+    }
+    return value;
+  }
+  return null;
+}
+
+const explicitConfigDir = parseConfigDirArg();
+if (explicitConfigDir) {
+  validatePath(explicitConfigDir);
+}
+const packageManager = detectPackageManager();
+
+console.log(banner);
+console.log(`  ${dim}Package manager detectado: ${packageManager}${reset}\n`);
+
+// Show help
+if (hasHelp) {
+  console.log(`  ${yellow}Uso:${reset}
+
+  ${cyan}npm:${reset}   npx elsabro [opciones]
+  ${cyan}pnpm:${reset}  pnpm dlx elsabro [opciones]
+  ${cyan}bun:${reset}   bunx elsabro [opciones]
+
+  ${yellow}Opciones:${reset}
+    ${cyan}-g, --global${reset}              Instalar globalmente (recomendado)
+    ${cyan}-l, --local${reset}               Instalar solo en este proyecto
+    ${cyan}-u, --uninstall${reset}           Desinstalar ELSABRO
+    ${cyan}--update${reset}                  Actualizar a la última versión
+    ${cyan}-c, --config-dir <ruta>${reset}   Directorio de configuración personalizado
+    ${cyan}-h, --help${reset}                Mostrar esta ayuda
+
+  ${yellow}Ejemplos:${reset}
+    ${dim}# Instalar globalmente (funciona en todos los proyectos)${reset}
+    npx elsabro --global
+    pnpm dlx elsabro --global
+    bunx elsabro --global
+
+    ${dim}# Instalar solo en este proyecto${reset}
+    npx elsabro --local
+
+    ${dim}# Actualizar${reset}
+    npx elsabro --update
+
+    ${dim}# Desinstalar${reset}
+    npx elsabro --global --uninstall
+
+  ${yellow}Después de instalar:${reset}
+    Abre Claude Code y escribe: ${cyan}/elsabro:start${reset}
+`);
+  process.exit(0);
+}
+
+// Check for newer version on npm
+const MAX_RESPONSE_SIZE = 100 * 1024; // 100KB limit for npm response
+
+async function checkLatestVersion() {
+  try {
+    const https = require('https');
+    return new Promise((resolve, reject) => {
+      const req = https.get('https://registry.npmjs.org/elsabro/latest', { timeout: 5000 }, (res) => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+          // Security: prevent memory exhaustion from large response
+          if (data.length > MAX_RESPONSE_SIZE) {
+            req.destroy();
+            resolve(null);
+          }
+        });
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            resolve(json.version || null);
+          } catch {
+            resolve(null);
+          }
+        });
+      });
+      req.on('error', () => resolve(null));
+      req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+  } catch {
+    return null;
+  }
+}
+
+// Handle update using execFileSync (safer than exec)
+if (hasUpdate) {
+  console.log(`  ${cyan}Verificando actualizaciones...${reset}\n`);
+
+  // Check if there's a newer version first to prevent infinite loops
+  checkLatestVersion().then((latestVersion) => {
+    if (!latestVersion) {
+      console.log(`  ${yellow}⚠${reset} No se pudo verificar la última versión`);
+      console.log(`  ${dim}Intentando actualizar de todas formas...${reset}\n`);
+    } else if (latestVersion === pkg.version) {
+      console.log(`  ${green}✓${reset} Ya tienes la última versión (${pkg.version})\n`);
+      process.exit(0);
+    } else {
+      console.log(`  ${cyan}Nueva versión disponible: ${latestVersion}${reset}`);
+      console.log(`  ${dim}Versión actual: ${pkg.version}${reset}\n`);
+    }
+
+    try {
+      // Use execFileSync with the package manager directly
+      // Use getExecutable for Windows compatibility
+      if (packageManager === 'pnpm') {
+        execFileSync(getExecutable('pnpm'), ['dlx', 'elsabro@latest', '--global'], { stdio: 'inherit' });
+      } else if (packageManager === 'bun') {
+        execFileSync(getExecutable('bunx'), ['elsabro@latest', '--global'], { stdio: 'inherit' });
+      } else {
+        execFileSync(getExecutable('npx'), ['elsabro@latest', '--global'], { stdio: 'inherit' });
+      }
+      console.log(`\n  ${green}✓${reset} ELSABRO actualizado correctamente\n`);
+    } catch (error) {
+      console.error(`\n  ${red}✗${reset} Error al actualizar: ${error.message}\n`);
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+} else {
+
+// Interactive prompt for location if not specified
+async function promptLocation() {
+  if (hasGlobal || hasLocal) return hasGlobal ? 'global' : 'local';
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    console.log(`  ${yellow}¿Dónde quieres instalar ELSABRO?${reset}\n`);
+    console.log(`  ${cyan}1)${reset} Global ${dim}(recomendado - funciona en todos los proyectos)${reset}`);
+    console.log(`  ${cyan}2)${reset} Local ${dim}(solo en este proyecto)${reset}\n`);
+
+    rl.question(`  Tu elección [1]: `, (answer) => {
+      rl.close();
+      resolve(answer === '2' ? 'local' : 'global');
+    });
+  });
+}
+
+// Copy directory recursively with security limits
+const MAX_DEPTH = 20;
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+
+function copyDir(src, dest, depth = 0) {
+  // Prevent stack overflow from deeply nested directories
+  if (depth > MAX_DEPTH) {
+    throw new Error(`Profundidad máxima excedida en: ${src}`);
+  }
+
+  // Check source is not a symlink (security: prevent symlink attacks)
+  const srcStats = fs.lstatSync(src);
+  if (srcStats.isSymbolicLink()) {
+    console.log(`  ${yellow}⚠${reset} Saltando symlink: ${src}`);
+    return;
+  }
+
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    // Check each entry for symlinks
+    const entryStats = fs.lstatSync(srcPath);
+    if (entryStats.isSymbolicLink()) {
+      console.log(`  ${yellow}⚠${reset} Saltando symlink: ${entry.name}`);
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, depth + 1);
+    } else {
+      // Check file size before copying
+      if (entryStats.size > MAX_FILE_SIZE) {
+        throw new Error(`Archivo demasiado grande: ${srcPath} (${Math.round(entryStats.size / 1024 / 1024)}MB)`);
+      }
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// Main install function
+async function install() {
+  const location = await promptLocation();
+  const isGlobal = location === 'global';
+
+  const baseDir = isGlobal
+    ? getGlobalDir(explicitConfigDir)
+    : path.join(process.cwd(), '.claude');
+
+  console.log(`\n  ${cyan}Instalando ELSABRO...${reset}`);
+  console.log(`  ${dim}Destino: ${baseDir}${reset}\n`);
+
+  // Create base directory
+  fs.mkdirSync(baseDir, { recursive: true });
+
+  // Directories to copy
+  const srcDir = path.join(__dirname, '..');
+  const copies = [
+    { src: 'commands/elsabro', dest: 'commands/elsabro', name: 'Comandos' },
+    { src: 'agents', dest: 'agents', name: 'Agentes' },
+    { src: 'skills', dest: 'skills', name: 'Skills' },
+    { src: 'templates', dest: 'templates', name: 'Templates' },
+    { src: 'workflows', dest: 'workflows', name: 'Workflows' },
+    { src: 'references', dest: 'references', name: 'Referencias' },
+    { src: 'hooks/dist', dest: 'hooks', name: 'Hooks' }
+  ];
+
+  const failures = [];
+
+  for (const item of copies) {
+    const srcPath = path.join(srcDir, item.src);
+    const destPath = path.join(baseDir, item.dest);
+
+    try {
+      // Safe removal: check for symlinks before removing
+      if (fs.existsSync(destPath)) {
+        const destStats = fs.lstatSync(destPath);
+        if (destStats.isSymbolicLink()) {
+          console.log(`  ${yellow}⚠${reset} Saltando symlink existente: ${destPath}`);
+          continue;
+        }
+        fs.rmSync(destPath, { recursive: true });
+      }
+
+      if (fs.existsSync(srcPath)) {
+        copyDir(srcPath, destPath);
+        console.log(`  ${green}✓${reset} ${item.name} instalados`);
+      } else {
+        console.log(`  ${yellow}⚠${reset} ${item.name} no encontrados (saltando)`);
+      }
+    } catch (error) {
+      console.log(`  ${red}✗${reset} Error instalando ${item.name}: ${error.message}`);
+      failures.push(item.name);
+    }
+  }
+
+  // Update settings.json for hooks
+  const settingsPath = path.join(baseDir, 'settings.json');
+  let settings = {};
+
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      settings = {};
+    }
+  }
+
+  // Add hook configurations
+  settings.hooks = settings.hooks || {};
+  settings.hooks.postToolUse = settings.hooks.postToolUse || [];
+
+  // Add version tracking
+  settings.elsabro = {
+    version: pkg.version,
+    installedAt: new Date().toISOString(),
+    packageManager: packageManager
+  };
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  console.log(`  ${green}✓${reset} Configuración actualizada`);
+
+  // Summary
+  console.log(`\n  ${green}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${reset}`);
+
+  if (failures.length === 0) {
+    console.log(`  ${green}✓${reset} ${bold}ELSABRO instalado correctamente${reset}`);
+    console.log(`\n  ${yellow}Próximos pasos:${reset}`);
+    console.log(`  1. Abre Claude Code`);
+    console.log(`  2. Escribe: ${cyan}/elsabro:start${reset}`);
+    console.log(`  3. ¡Empieza a crear tu app!\n`);
+
+    console.log(`  ${dim}Comandos útiles:${reset}`);
+    console.log(`  ${cyan}/elsabro:start${reset}  - Wizard para empezar`);
+    console.log(`  ${cyan}/elsabro:help${reset}   - Ver todos los comandos`);
+    console.log(`  ${cyan}/elsabro:update${reset} - Actualizar ELSABRO\n`);
+  } else {
+    console.log(`  ${yellow}⚠${reset} ELSABRO instalado con algunos errores`);
+    console.log(`  Componentes fallidos: ${failures.join(', ')}\n`);
+  }
+
+  console.log(`  ${green}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${reset}\n`);
+}
+
+// Uninstall function
+async function uninstall() {
+  const location = await promptLocation();
+  const isGlobal = location === 'global';
+
+  const baseDir = isGlobal
+    ? getGlobalDir(explicitConfigDir)
+    : path.join(process.cwd(), '.claude');
+
+  console.log(`\n  ${cyan}Desinstalando ELSABRO...${reset}\n`);
+
+  const toRemove = [
+    'commands/elsabro',
+    'agents',
+    'skills',
+    'templates',
+    'workflows',
+    'references'
+  ];
+
+  for (const item of toRemove) {
+    const itemPath = path.join(baseDir, item);
+    if (fs.existsSync(itemPath)) {
+      // Safe removal: check for symlinks before removing
+      const itemStats = fs.lstatSync(itemPath);
+      if (itemStats.isSymbolicLink()) {
+        console.log(`  ${yellow}⚠${reset} Saltando symlink: ${item}`);
+        continue;
+      }
+      fs.rmSync(itemPath, { recursive: true });
+      console.log(`  ${green}✓${reset} Eliminado: ${item}`);
+    }
+  }
+
+  // Remove from settings
+  const settingsPath = path.join(baseDir, 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      delete settings.elsabro;
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  console.log(`\n  ${green}✓${reset} ELSABRO desinstalado correctamente\n`);
+}
+
+// Main (note: update handling is above with its own process.exit)
+  if (hasUninstall) {
+    uninstall().catch((error) => {
+      console.error(`  ${red}✗${reset} Error: ${error.message}`);
+      process.exit(1);
+    });
+  } else {
+    install().catch((error) => {
+      console.error(`  ${red}✗${reset} Error: ${error.message}`);
+      process.exit(1);
+    });
+  }
+}

package/commands/elsabro/add-phase.md

@@ -0,0 +1,114 @@
+---
+name: add-phase
+description: Agregar una nueva fase al final del milestone actual
+---
+
+# /elsabro:add-phase
+
+<command-name>add-phase</command-name>
+
+## Propósito
+
+Agregar una nueva fase al milestone activo. Útil cuando se descubre trabajo adicional necesario.
+
+## Uso
+
+```bash
+# Agregar fase básica
+/elsabro:add-phase "Documentation"
+
+# Agregar con descripción
+/elsabro:add-phase "Documentation" --desc="Write user guides and API docs"
+
+# Agregar a milestone específico
+/elsabro:add-phase "Documentation" --milestone=M001
+
+# Agregar con estimación
+/elsabro:add-phase "Documentation" --estimate=3d
+```
+
+## Proceso
+
+### 1. Crear Fase
+
+```
+User: /elsabro:add-phase "Integration Testing"
+
+ELSABRO: Creating new phase...
+
+Phase added to M001:
+┌──────────────────────────────────────┐
+│  P5: Integration Testing             │
+│  Status: ⬜ Pending                   │
+│  Estimate: TBD                       │
+│  Dependencies: P4                    │
+└──────────────────────────────────────┘
+
+Define tasks for this phase? (y/n)
+```
+
+### 2. Definir Tasks (Opcional)
+
+Si responde 'y':
+
+```
+Enter tasks (one per line, empty to finish):
+> Set up integration test environment
+> Write API integration tests
+> Write E2E tests for critical flows
+>
+
+Tasks added:
+- [ ] Set up integration test environment
+- [ ] Write API integration tests
+- [ ] Write E2E tests for critical flows
+```
+
+## Actualización Automática
+
+Actualiza `PHASES.md` y `MILESTONE.md`:
+
+```markdown
+## Phases
+
+| # | Phase | Status | Tasks | ETA |
+|---|-------|--------|-------|-----|
+| P1 | Design | ✅ Done | 5/5 | W1 |
+| P2 | Backend | ✅ Done | 8/8 | W2 |
+| P3 | Frontend | 🟡 WIP | 4/6 | W3 |
+| P4 | Testing | ⬜ Pending | 0/3 | W4 |
+| P5 | Integration Testing | ⬜ NEW | 0/3 | W5 |  ← Added
+```
+
+## Opciones
+
+```bash
+--milestone, -m    # Milestone target (default: active)
+--desc, -d         # Phase description
+--estimate, -e     # Time estimate (1d, 2w, etc.)
+--after, -a        # Insert after specific phase
+--deps             # Dependencies (comma-separated)
+--tasks            # Initial tasks (comma-separated)
+```
+
+## Validaciones
+
+- Verifica milestone existe
+- Verifica nombre único de fase
+- Sugiere dependencias basado en orden
+
+## Output
+
+```
+✓ Phase "Integration Testing" added to M001
+
+  Position: P5 (after P4: Testing)
+  Status: Pending
+  Tasks: 3 defined
+
+  Impact on milestone:
+  - Original ETA: 2024-02-15
+  - New ETA: 2024-02-22 (+1 week)
+
+View phases: /elsabro:progress --phases
+```