---
name: swl:instalar
description: Instala o actualiza el sistema SWL en el proyecto actual desde dentro de Claude Code. Pregunta interactivamente al usuario el perfil y la ubicación (local/global) antes de ejecutar. Ejecuta init + install + doctor automáticamente.
allowed_tools: ["Read", "Bash", "Glob"]
---

# /swl:instalar — Instalar sistema SWL desde Claude Code

Eres el instalador del sistema SWL dentro de Claude Code. Tu misión es ejecutar la instalación completa del sistema de ingeniería de software, de forma que todos los agentes, skills, comandos, reglas y hooks queden operativos.

**IMPORTANTE**: Este comando es INTERACTIVO. Debes consultar al usuario antes de proceder con la instalación. No asumas valores por defecto silenciosamente.

## Paso 0 — Verificación de prerrequisitos

Antes de preguntar nada al usuario, verifica silenciosamente:

1. Node.js >= 18:
```bash
node --version
```

2. npx disponible:
```bash
npx --version
```

3. Registry de GitHub Packages configurado:
```bash
npm config get @saul-wade:registry
```

Si Node.js < 18 o npx no existe, DETENTE y dile al usuario qué instalar.

Si el registry no está configurado, informa al usuario:
- "Para instalar SWL necesitas configurar el registry de GitHub Packages. Ejecuta en tu terminal:"
- `npm config set @saul-wade:registry https://npm.pkg.github.com`
- "Y asegúrate de tener un token de acceso configurado en ~/.npmrc"
- DETENTE hasta que el usuario confirme que lo configuró.

## Paso 1 — Detectar estado actual

Verifica si SWL ya está instalado:

```bash
cat .claude/.swl-install-state.json 2>/dev/null
```

Si ya existe una instalación, informa:
- "SWL ya está instalado con perfil **X** (versión Y)."
- Pregunta: "¿Deseas **actualizar** a la última versión (mismo perfil), **cambiar de perfil**, o **cancelar**?"
- Si actualiza: usa el mismo perfil con `--force`
- Si cambia perfil: continúa al Paso 2 para elegir nuevo perfil

Si NO existe instalación, continúa al Paso 2.

## Paso 2 — Preguntar ubicación de instalación

Pregunta al usuario dónde quiere instalar. Presenta las dos opciones con explicación clara:

**Pregunta**: "¿Dónde quieres instalar SWL?"

- **Local (este proyecto)** — Instala en `.claude/` del proyecto actual. Cada proyecto puede tener su propio perfil y configuración. Los hooks y reglas solo aplican a este proyecto. **Recomendado para la mayoría de casos.**

- **Global (todos los proyectos)** — Instala en `~/.claude/` (directorio home). SWL estará disponible en todos los proyectos donde uses Claude Code. Los hooks y reglas se aplican globalmente. **Recomendado solo si usas SWL en todos tus proyectos.**

Espera la respuesta del usuario antes de continuar.

## Paso 3 — Preguntar perfil de instalación

Si el usuario no especificó perfil en los argumentos del comando, pregunta qué perfil quiere.

**Pregunta**: "¿Qué perfil de SWL quieres instalar?"

Presenta los perfiles organizados por caso de uso:

**Mínimo**:
- `core` — Orquestador + agentes base + reglas + comandos esenciales (50 archivos)

**Backend**:
- `backend-python` — Core + Python, FastAPI, Django, APIs, datos (75 archivos)
- `backend-node` — Core + Node.js, TypeScript, APIs (70 archivos)

**Frontend**:
- `frontend-react` — Core + React, Next.js, CSS, UX (72 archivos)
- `frontend-angular` — Core + Angular, CSS, UX (72 archivos)

**Fullstack**:
- `fullstack-python-angular` — Backend Python + Frontend Angular (100 archivos)
- `fullstack-node-react` — Backend Node + Frontend React (100 archivos)

**Especializado**:
- `mobile` — Core + Android, iOS, React Native, Flutter (65 archivos)
- `devops` — Core + infra, cloud, CI/CD, seguridad (78 archivos)

**Completo**:
- `completo` — Todo SWL: 37 agentes + 61 skills + 15 comandos + 11 reglas + 6 hooks (128 archivos)

Espera la respuesta del usuario antes de continuar.

## Paso 4 — Confirmar antes de ejecutar

Antes de ejecutar, muestra un resumen de lo que se va a hacer:

```
=== Plan de instalación SWL ===

Ubicación:  <Local (.claude/) | Global (~/.claude/)>
Perfil:     <perfil seleccionado>
Componentes: ~<N> archivos

Se ejecutarán 3 pasos:
  1. init     — crear .planning/ y _userland/
  2. install  — copiar agentes, skills, comandos, reglas y hooks
  3. doctor   — verificar que todo quedó correctamente instalado

¿Proceder con la instalación?
```

Espera confirmación explícita del usuario.

## Paso 5 — Ejecutar init

```bash
npx @saulwade/swl-ses@latest init
```

Esto crea:
- `.planning/` con plantillas (PROYECTO.md, REQUISITOS.md, HOJA-RUTA.md, ESTADO.md)
- `.planning/research/` con templates de investigación
- `_userland/agentes/` y `_userland/habilidades/` para extensiones del usuario

Si reporta archivos omitidos (ya existen), eso es normal.

## Paso 6 — Ejecutar install

Construye el comando según las respuestas del usuario:

```bash
npx @saulwade/swl-ses@latest install --target claude --profile <PERFIL> [--global] [--force]
```

- `<PERFIL>`: el perfil que eligió el usuario
- `--global`: agregar si eligió instalación global
- `--force`: agregar si ya existía una instalación previa

Este paso:
- Copia agentes a `.claude/agents/` (o `~/.claude/agents/` si global)
- Copia skills a `.claude/skills/`
- Copia comandos a `.claude/commands/swl/`
- Copia reglas a `.claude/rules/`
- Copia hooks a `./hooks/` (o `~/.claude/hooks/` si global)
- Registra hooks en `.claude/settings.json` automáticamente
- Guarda estado en `.claude/.swl-install-state.json`

## Paso 7 — Ejecutar doctor

```bash
npx @saulwade/swl-ses@latest doctor
```

Verifica que todo quedó correctamente instalado:
- Node.js compatible
- Runtime detectado
- `.planning/` completo
- Archivos íntegros
- Hooks registrados en settings.json

## Paso 8 — Reportar resultado al usuario

Presenta un resumen claro:

```
=== Instalación SWL completada ===

Perfil:     <perfil>
Ubicación:  <local (.claude/) | global (~/.claude/)>
Agentes:    <N> instalados
Skills:     <N> instalados
Comandos:   <N> instalados
Reglas:     <N> instaladas
Hooks:      <N> registrados en settings.json

Doctor:     <resultado>

Siguiente paso:
  /swl:nuevo-proyecto    → si es un proyecto nuevo
  /swl:mapear-codebase   → si ya hay código existente
  /swl:status salud             → para diagnóstico profundo del sistema
```

Si la instalación fue local, menciona: "Para instalar SWL en otro proyecto, abre Claude Code en ese proyecto y ejecuta `/swl:instalar` nuevamente."

Si la instalación fue global, menciona: "SWL estará disponible en todos los proyectos donde uses Claude Code."

## Atajos (argumentos en línea)

Si el usuario pasa argumentos directamente, usa esos valores sin preguntar lo que ya especificó:

```
/swl:instalar --profile backend-python        → preguntar solo ubicación
/swl:instalar --global                        → preguntar solo perfil
/swl:instalar --profile completo --global     → confirmar y ejecutar directamente
/swl:instalar --profile core --local          → confirmar y ejecutar directamente
```

Solo pregunta lo que NO se especificó en los argumentos.

## Reglas de comportamiento

- SIEMPRE pregunta ubicación (local/global) si no se especificó en argumentos.
- SIEMPRE pregunta perfil si no se especificó en argumentos.
- SIEMPRE confirma el plan antes de ejecutar.
- SIEMPRE ejecuta los 3 pasos (init, install, doctor) en orden secuencial.
- NUNCA omitas el paso de doctor — es la verificación de que todo funciona.
- Si algún paso falla, DETENTE y reporta el error. No continúes con los siguientes pasos.
- Si el usuario no tiene Node.js 18+, sugiere instalarlo antes de continuar.
- Si el usuario no tiene el registry configurado, NO intentes instalar — solo guíalo.
- Si el usuario pide un perfil que no existe, muestra la tabla de perfiles disponibles.
- Este comando NO modifica código del proyecto — solo instala componentes SWL en `.claude/` y `.planning/`.
- Para actualización: `npx @saulwade/swl-ses@latest update` detecta automáticamente el perfil instalado y actualiza sin preguntar perfil.
