skillctl 0.0.3

package/.github/workflows/release.yml

@@ -0,0 +1,42 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*' # Se activa cuando subes un tag como v0.0.1
+permissions:
+  contents: write
+jobs:
+  build:
+    name: Build for ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            artifact_name: skillctl
+            asset_name: skillctl-linux
+          - os: macos-latest
+            artifact_name: skillctl
+            asset_name: skillctl-macos
+          - os: windows-latest
+            artifact_name: skillctl.exe
+            asset_name: skillctl-win.exe
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@stable
+
+    - name: Build
+      run: cargo build --release --verbose
+
+    - name: Upload binaries to Release
+      uses: svenstaro/upload-release-action@v2
+      with:
+        repo_token: ${{ secrets.GITHUB_TOKEN }}
+        file: target/release/${{ matrix.artifact_name }}
+        asset_name: ${{ matrix.asset_name }}
+        tag: ${{ github.ref }}
+        overwrite: true

package/BOOTSTRAP.md

@@ -0,0 +1,308 @@
+# Guía de Bootstrap: Primera Publicación
+
+Esta guía te ayudará a publicar la primera versión del proyecto y resolver el problema del "huevo y la gallina".
+
+## 🎯 Objetivo
+
+Publicar la versión `v0.0.1` del proyecto para que los usuarios puedan ejecutar:
+
+```bash
+npx skillctl init
+```
+
+## 📋 Pre-requisitos
+
+- [x] Cuenta de GitHub
+- [x] Cuenta de NPM (crear en https://www.npmjs.com/signup)
+- [x] Rust instalado (`curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`)
+- [x] Node.js instalado
+- [x] Git configurado
+
+## 🚀 Pasos para la Primera Publicación
+
+### Paso 1: Compilar el Binario Rust
+
+```bash
+# Asegúrate de estar en la raíz del proyecto
+cd /home/clasing/proyects/umibu/agent-skill
+
+# Compilar en modo release
+cargo build --release
+
+# Verificar que el binario se creó correctamente
+ls -lh target/release/skill-cli
+```
+
+**Resultado esperado:**
+
+```
+-rwxr-xr-x 1 user user 3.2M Feb  8 22:30 target/release/skillctl
+```
+
+### Paso 2: Probar el Binario Localmente
+
+```bash
+# Ejecutar el binario directamente
+./target/release/skillctl --help
+
+# Probar el comando init
+./target/release/skillctl init
+
+# Verificar que se creó skills.toml
+cat skills.toml
+```
+
+### Paso 3: Preparar el Repositorio
+
+```bash
+# Asegúrate de que todos los cambios están commiteados
+git status
+
+# Si hay cambios pendientes:
+git add .
+git commit -m "Prepare for v0.0.1 release"
+
+# Subir a GitHub
+git push origin main
+```
+
+### Paso 4: Crear el Release en GitHub (CRÍTICO)
+
+Este es el paso más importante. **Sin este paso, el script de NPM no podrá descargar el binario.**
+
+#### Opción A: Manual (Recomendado para la primera vez)
+
+1. Ve a tu repositorio: https://github.com/joeldevz/agent-skill
+2. Click en "Releases" (en la barra lateral derecha)
+3. Click en "Draft a new release"
+4. Completa el formulario:
+   - **Tag version:** `v0.0.1`
+   - **Release title:** `v0.0.1 - Initial Release`
+   - **Description:**
+
+     ````markdown
+     ## 🎉 Primera versión de Skill CLI Tool
+
+     Gestor de Skills para Agentes de IA.
+
+     ### Características
+
+     - ✅ Comando `init` para inicializar proyectos
+     - ✅ Comando `list` para listar skills
+     - ✅ Soporte para Cursor, Antigravity y VSCode
+
+     ### Instalación
+
+     ```bash
+     npx skillctl init
+     ```
+     ````
+
+     ```
+
+     ```
+
+5. **IMPORTANTE: Subir los binarios**
+   - Click en "Attach binaries by dropping them here or selecting them"
+   - Sube el archivo: `target/release/skillctl`
+   - **RENOMBRA el archivo a:** `skillctl-linux` (sin extensión)
+
+   > **Nota:** Para Windows y macOS, necesitarás compilar en esas plataformas o usar GitHub Actions (ver Opción B)
+
+6. Click en "Publish release"
+
+#### Opción B: Automático con GitHub Actions
+
+```bash
+# Crear y subir el tag
+git tag v0.0.1
+git push origin v0.0.1
+```
+
+Esto activará el workflow `.github/workflows/release.yml` que:
+
+1. Compilará el binario en Linux, Windows y macOS
+2. Subirá automáticamente los binarios al release
+
+**Espera a que termine el workflow** (ve a la pestaña "Actions" en GitHub)
+
+### Paso 5: Verificar que el Release está Correcto
+
+1. Ve a: https://github.com/joeldevz/agent-skill/releases/tag/v0.0.1
+2. Verifica que aparezcan los binarios:
+   - `skill-cli-linux`
+   - `skill-cli-win.exe` (si usaste GitHub Actions)
+   - `skill-cli-macos` (si usaste GitHub Actions)
+
+3. **Prueba la URL de descarga:**
+
+   ```bash
+   # Debería descargar el binario (no dar error 404)
+   curl -L https://github.com/joeldevz/agent-skill/releases/download/v0.0.1/skillctl-linux -o test-binary
+
+   # Verificar que se descargó
+   ls -lh test-binary
+
+   # Limpiar
+   rm test-binary
+   ```
+
+### Paso 6: Probar el Script de Instalación NPM
+
+```bash
+# Probar el script de descarga
+node scripts/install.js
+```
+
+**Resultado esperado:**
+
+```
+⬇️  Descargando skillctl desde: https://github.com/joeldevz/agent-skill/releases/download/v0.0.1/skillctl-linux
+✅ Instalación completada.
+```
+
+**Verificar:**
+
+```bash
+ls -lh bin/skillctl
+# Debería mostrar el binario descargado
+```
+
+### Paso 7: Probar el Wrapper Completo
+
+```bash
+# Probar el wrapper de Node.js
+node bin/run.js --help
+node bin/run.js init
+node bin/run.js list
+```
+
+### Paso 8: Publicar en NPM
+
+```bash
+# Login en NPM (primera vez)
+npm login
+# Introduce tu usuario, contraseña y email
+
+# Verificar que estás logueado
+npm whoami
+
+# Publicar el paquete
+npm publish
+```
+
+**Resultado esperado:**
+
+```
++ skillctl@0.0.1
+```
+
+### Paso 9: Probar la Instalación desde NPM
+
+```bash
+# Crear una carpeta de prueba
+mkdir /tmp/test-skill-cli
+cd /tmp/test-skill-cli
+
+# Probar con npx (sin instalar)
+npx skillctl init
+
+# Verificar que funcionó
+ls -la
+# Debería mostrar skills.toml y .cursor/
+```
+
+## ✅ Checklist de Verificación
+
+- [ ] Binario compilado correctamente
+- [ ] Release v0.0.1 creado en GitHub
+- [ ] Binarios subidos al release (al menos Linux)
+- [ ] URL de descarga funciona (no da 404)
+- [ ] Script `install.js` descarga correctamente
+- [ ] Wrapper `run.js` ejecuta el binario
+- [ ] Publicado en NPM
+- [ ] `npx skill-cli-tool init` funciona
+
+## 🐛 Troubleshooting
+
+### Error: "404 Not Found" al descargar
+
+**Causa:** El release no existe o los binarios no están subidos.
+
+**Solución:**
+
+1. Verifica que el release existe: https://github.com/joeldevz/agent-skill/releases
+2. Verifica que el tag es exactamente `v0.0.1`
+3. Verifica que el binario se llama exactamente `skillctl-linux`
+
+### Error: "Permission denied" al ejecutar el binario
+
+**Causa:** El binario no tiene permisos de ejecución.
+
+**Solución:**
+
+```bash
+chmod +x bin/skillctl
+```
+
+### Error: "Package name already exists" en NPM
+
+**Causa:** El nombre `skill-cli-tool` ya está tomado.
+
+**Solución:**
+
+1. Cambia el nombre en `package.json`:
+   ```json
+   "name": "@tu-usuario/skillctl"
+   ```
+2. Publica de nuevo:
+   ```bash
+   npm publish --access public
+   ```
+
+### Error: "GITHUB_TOKEN" en GitHub Actions
+
+**Causa:** El token no tiene permisos suficientes.
+
+**Solución:**
+
+1. Ve a Settings → Actions → General
+2. En "Workflow permissions", selecciona "Read and write permissions"
+3. Guarda y vuelve a ejecutar el workflow
+
+## 🎉 ¡Éxito!
+
+Si llegaste aquí, tu proyecto está publicado y funcionando. Los usuarios ahora pueden ejecutar:
+
+```bash
+npx skillctl init
+```
+
+## 📚 Próximos Pasos
+
+1. **Implementar el comando `add`** para añadir skills
+2. **Añadir tests** para asegurar calidad
+3. **Mejorar la documentación** con más ejemplos
+4. **Crear un video tutorial** de uso
+5. **Compartir en redes sociales** y comunidades
+
+## 🔄 Para Futuras Versiones
+
+Cuando quieras publicar `v0.0.2`:
+
+1. Actualiza las versiones:
+   - `Cargo.toml`: `version = "0.0.2"`
+   - `package.json`: `"version": "0.0.2"`
+   - `scripts/install.js`: `const VERSION = "v0.0.2"`
+
+2. Compila y publica:
+   ```bash
+   cargo build --release
+   git add .
+   git commit -m "Bump version to 0.0.2"
+   git tag v0.0.2
+   git push origin main --tags
+   npm publish
+   ```
+
+El workflow de GitHub Actions se encargará del resto automáticamente.

package/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "skillctl"
+version = "0.0.3"
+edition = "2021"
+authors = ["Your Name <your.email@example.com>"]
+description = "Gestor de Skills para Agentes de IA"
+license-file = "LICENSE"
+
+[[bin]]
+name = "skillctl"
+path = "src/main.rs"
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.8"
+anyhow = "1.0"
+reqwest = { version = "0.11", features = ["blocking", "json"] }
+tokio = { version = "1.35", features = ["full"] }
+
+[profile.release]
+opt-level = "z"     # Optimizar para tamaño
+lto = true          # Link Time Optimization
+codegen-units = 1   # Mejor optimización
+strip = true        # Eliminar símbolos de debug

package/EXAMPLES.md

@@ -0,0 +1,236 @@
+# Ejemplo de Uso: Skillctl
+
+## Escenario: Configurar un Proyecto Nuevo
+
+### 1. Inicializar el Proyecto
+
+```bash
+# Crear una nueva carpeta para tu proyecto
+mkdir mi-proyecto-ia
+cd mi-proyecto-ia
+
+# Inicializar el gestor de skills
+npx skill-cli-tool init
+```
+
+**Resultado:**
+
+```
+✅ Proyecto inicializado. Se ha creado 'skills.toml'.
+🚀 Prueba ahora: npx skillctl add <url> --skill <nombre>
+```
+
+**Archivos creados:**
+
+- `skills.toml` - Manifiesto de skills
+- `.cursor/skills/` - Carpeta para skills descargadas
+
+### 2. Añadir Skills
+
+```bash
+# Añadir skill de TypeScript
+npx skillctl add https://github.com/wshobson/agents --skill typescript
+
+# Añadir skill de Python
+npx skillctl add https://github.com/wshobson/agents --skill python
+
+# Añadir skill personalizada
+npx skillctl add https://github.com/tu-usuario/tu-repo --skill custom-skill
+```
+
+### 3. Ver Skills Instaladas
+
+```bash
+npx agent-skill list
+```
+
+**Resultado:**
+
+```
+📦 Skills instaladas (2):
+  • typescript (https://github.com/wshobson/agents)
+    └─ Branch: main | Path: .cursor/skills/typescript/SKILL.md
+  • python (https://github.com/wshobson/agents)
+    └─ Branch: main | Path: .cursor/skills/python/SKILL.md
+```
+
+### 4. Sincronizar con Editores
+
+```bash
+# Sincronizar con Cursor
+npx agent-skill sync --editors cursor
+
+# Sincronizar con múltiples editores
+npx agent-skill sync --editors cursor,antigravity,vscode
+```
+
+**Archivos generados:**
+
+- `.cursorrules` - Configuración para Cursor
+- `.antigravity` - Configuración para Antigravity
+- `.github/copilot-instructions.md` - Instrucciones para GitHub Copilot
+
+### 5. Actualizar Skills
+
+```bash
+# Actualizar todas las skills a sus últimas versiones
+npx agent-skill update
+```
+
+**Resultado:**
+
+```
+🔄 Buscando actualizaciones para 2 skills...
+   ⬇️ Actualizando typescript...
+   ⬇️ Actualizando python...
+✅ Todas las skills están al día.
+✅ .cursorrules actualizado.
+✅ .antigravity actualizado.
+```
+
+## Estructura del Proyecto Resultante
+
+```
+mi-proyecto-ia/
+├── .cursor/
+│   └── skills/
+│       ├── typescript/
+│       │   └── SKILL.md
+│       └── python/
+│           └── SKILL.md
+├── .github/
+│   └── copilot-instructions.md
+├── .cursorrules
+├── .antigravity
+└── skills.toml
+```
+
+## Contenido de `skills.toml`
+
+```toml
+# Manifiesto de Skills
+version = "1.0"
+
+[skills.typescript]
+url = "https://github.com/wshobson/agents"
+branch = "main"
+local_path = ".cursor/skills/typescript/SKILL.md"
+last_updated = "2026-02-08T22:30:00Z"
+
+[skills.python]
+url = "https://github.com/wshobson/agents"
+branch = "main"
+local_path = ".cursor/skills/python/SKILL.md"
+last_updated = "2026-02-08T22:30:00Z"
+```
+
+## Integración con Cursor
+
+Una vez sincronizado, Cursor automáticamente:
+
+1. Lee el archivo `.cursorrules`
+2. Carga las skills referenciadas
+3. Usa las instrucciones de las skills en sus respuestas
+
+**Ejemplo de `.cursorrules` generado:**
+
+```markdown
+# Rules generadas por Skillctl
+
+## Skill: typescript
+
+Reference: .cursor/skills/typescript/SKILL.md
+
+## Skill: python
+
+Reference: .cursor/skills/python/SKILL.md
+```
+
+## Flujo de Trabajo Diario
+
+```bash
+# Mañana: Actualizar skills
+npx skillctl update
+
+# Durante el día: Añadir nueva skill si es necesario
+npx skillctl add <url> --skill <nombre>
+
+# Verificar configuración
+npx skillctl list
+```
+
+## Compartir Configuración con el Equipo
+
+1. **Commitear `skills.toml`** al repositorio:
+
+   ```bash
+   git add skills.toml
+   git commit -m "Add skill configuration"
+   git push
+   ```
+
+2. **Otros miembros del equipo** solo necesitan:
+   ```bash
+   git pull
+   npx agent-skill update  # Descarga todas las skills del manifiesto
+   ```
+
+## Troubleshooting
+
+### Problema: "El binario no se encuentra"
+
+```bash
+# Solución: Reinstalar el paquete
+npm install --force skill-cli-tool
+```
+
+### Problema: "No se encontró skills.toml"
+
+```bash
+# Solución: Inicializar el proyecto
+npx skill-cli-tool init
+```
+
+### Problema: Skills desactualizadas
+
+```bash
+# Solución: Forzar actualización
+npx skill-cli-tool update
+```
+
+## Casos de Uso Avanzados
+
+### Usar diferentes branches
+
+```bash
+# Editar skills.toml manualmente
+[skills.typescript-beta]
+url = "https://github.com/wshobson/agents"
+branch = "beta"  # <-- Cambiar branch
+local_path = ".cursor/skills/typescript-beta/SKILL.md"
+last_updated = "2026-02-08T22:30:00Z"
+
+# Actualizar
+npx skill-cli-tool update
+```
+
+### Crear skills personalizadas
+
+1. Crear un repositorio con la estructura:
+
+   ```
+   mi-skill/
+   └── SKILL.md
+   ```
+
+2. Añadir la skill:
+   ```bash
+   npx skill-cli-tool add https://github.com/mi-usuario/mi-skill --skill mi-skill
+   ```
+
+## Próximos Pasos
+
+- Explorar skills disponibles en GitHub
+- Crear tus propias skills personalizadas
+- Compartir configuración con tu equipo
+- Automatizar actualizaciones en CI/CD

package/LICENSE

@@ -0,0 +1,71 @@
+LICENCIA DE SOFTWARE PROPIETARIO
+
+Copyright (c) 2026 Skill CLI Tool. Todos los derechos reservados.
+
+TÉRMINOS Y CONDICIONES DE USO
+
+1. CONCESIÓN DE LICENCIA LIMITADA
+
+   Se concede una licencia limitada, no exclusiva, no transferible y revocable
+   para usar este software únicamente para fines personales y no comerciales.
+
+2. RESTRICCIONES
+
+   NO está permitido:
+
+   a) Usar este software con fines comerciales sin autorización escrita explícita
+   b) Modificar, adaptar, traducir o crear obras derivadas del software
+   c) Realizar ingeniería inversa, descompilar o desensamblar el software
+   d) Redistribuir, sublicenciar, vender, alquilar o prestar el software
+   e) Eliminar o alterar avisos de derechos de autor o marcas comerciales
+   f) Publicar o compartir el código fuente sin autorización explícita
+   g) Usar el software para crear productos o servicios competidores
+
+3. USO COMERCIAL
+
+   Cualquier uso comercial de este software requiere una licencia comercial
+   separada. Para obtener una licencia comercial, contacte al titular de los
+   derechos de autor.
+
+4. PROPIEDAD INTELECTUAL
+
+   Este software y todos los derechos de propiedad intelectual asociados son
+   y permanecerán como propiedad exclusiva del titular de los derechos de autor.
+   No se transfiere ningún derecho de propiedad mediante esta licencia.
+
+5. CONTRIBUCIONES
+
+   Cualquier contribución al proyecto se considerará cedida al titular de los
+   derechos de autor bajo los mismos términos restrictivos de esta licencia.
+
+6. TERMINACIÓN
+
+   Esta licencia se revocará automáticamente si incumple cualquiera de estos
+   términos. Al terminar, debe cesar todo uso del software y destruir todas
+   las copias en su posesión.
+
+7. GARANTÍA LIMITADA
+
+   ESTE SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO,
+   EXPRESA O IMPLÍCITA, INCLUYENDO PERO NO LIMITADO A GARANTÍAS DE
+   COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN.
+
+8. LIMITACIÓN DE RESPONSABILIDAD
+
+   EN NINGÚN CASO EL TITULAR DE LOS DERECHOS DE AUTOR SERÁ RESPONSABLE DE
+   NINGÚN RECLAMO, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN DE
+   CONTRATO, AGRAVIO O DE OTRO MODO, QUE SURJA DE, FUERA DE O EN CONEXIÓN
+   CON EL SOFTWARE O EL USO U OTROS TRATOS EN EL SOFTWARE.
+
+9. LEY APLICABLE
+
+   Esta licencia se regirá e interpretará de acuerdo con las leyes aplicables,
+   sin tener en cuenta sus disposiciones sobre conflictos de leyes.
+
+10. CONTACTO PARA LICENCIAS COMERCIALES
+
+    Para consultas sobre licencias comerciales o permisos especiales:
+    Email: [TU_EMAIL_AQUI]
+    Web: [TU_WEB_AQUI]
+
+Al usar este software, usted acepta estar sujeto a los términos de esta licencia.

package/README.md

@@ -0,0 +1,236 @@
+# Skillctl: Agent Skill Manager
+
+Gestor de Skills para Agentes de IA (Cursor, Antigravity, VSCode Copilot)
+
+## 🚀 Inicio Rápido para Usuarios
+
+### Instalación y Uso
+
+No necesitas instalar nada globalmente. Simplemente usa `npx`:
+
+```bash
+# 1. Inicializar un nuevo proyecto
+npx skillctl init
+
+# 2. Añadir una skill
+npx skillctl add https://github.com/wshobson/agents --skill typescript
+
+# 3. Listar skills instaladas
+npx skillctl list
+
+# 4. Actualizar todas las skills
+npx skillctl update
+
+# 5. Sincronizar con editores
+npx skillctl sync --editors cursor,antigravity
+```
+
+## 🔧 Desarrollo: Ciclo de Vida del Proyecto
+
+### Estructura del Proyecto
+
+```
+agent-skill/
+├── src/              # Código Rust
+│   └── main.rs
+├── bin/              # Wrapper Node.js
+│   └── run.js
+├── scripts/          # Scripts de instalación
+│   └── install.js
+├── Cargo.toml        # Configuración Rust
+└── package.json      # Configuración NPM
+```
+
+### Paso 1: Compilar el Binario Rust
+
+```bash
+# Instalar Rust si no lo tienes
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Compilar en modo release
+cargo build --release
+
+# El binario estará en: target/release/skillctl
+```
+
+### Paso 2: Crear el Release en GitHub (Primera vez)
+
+1. **Asegúrate de que `Cargo.toml` tenga la versión `0.0.1`**
+2. **Compila el binario** (paso anterior)
+3. **Sube tus cambios a GitHub:**
+
+   ```bash
+   git add .
+   git commit -m "Initial release v0.0.1"
+   git push origin main
+   ```
+
+4. **Crea el Release en GitHub:**
+   - Ve a tu repositorio en GitHub
+   - Click en "Releases" → "Draft a new release"
+   - Tag: `v0.0.1`
+   - Title: `v0.0.1 - Initial Release`
+   - **Sube los binarios compilados:**
+     - `target/release/skillctl` → Renombrar a `skillctl-linux`
+     - Para Windows: `target/release/skillctl.exe` → Renombrar a `skillctl-win.exe`
+     - Para macOS: compilar en Mac y renombrar a `skillctl-macos`
+   - Publica la Release
+
+### Paso 3: Probar la Descarga Localmente
+
+Antes de publicar en NPM, prueba que el script de descarga funciona:
+
+```bash
+# Ejecutar el script de instalación manualmente
+node scripts/install.js
+
+# Verificar que se descargó el binario
+ls -la bin/
+
+# Probar el comando
+node bin/run.js init
+node bin/run.js list
+```
+
+### Paso 4: Publicar en NPM
+
+```bash
+# Login en NPM (primera vez)
+npm login
+
+# Publicar el paquete
+npm publish
+```
+
+### Paso 5: Automatización con GitHub Actions
+
+El archivo `.github/workflows/release.yml` automatiza la compilación y publicación:
+
+```yaml
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build
+        run: cargo build --release
+
+      - name: Upload Release Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ github.event.release.upload_url }}
+          asset_path: ./target/release/skill-cli${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+          asset_name: skill-cli-${{ matrix.os == 'ubuntu-latest' && 'linux' || matrix.os == 'windows-latest' && 'win.exe' || 'macos' }}
+          asset_content_type: application/octet-stream
+```
+
+## 🔄 Flujo de Actualización de Versiones
+
+1. **Actualiza la versión en ambos archivos:**
+   - `Cargo.toml`: `version = "0.0.2"`
+   - `package.json`: `"version": "0.0.2"`
+   - `scripts/install.js`: `const VERSION = "v0.0.2"`
+
+2. **Compila y crea el tag:**
+
+   ```bash
+   cargo build --release
+   git add .
+   git commit -m "Bump version to 0.0.2"
+   git tag v0.0.2
+   git push origin main --tags
+   ```
+
+3. **Crea el Release en GitHub** (o usa GitHub Actions)
+
+4. **Publica en NPM:**
+   ```bash
+   npm publish
+   ```
+
+## 📦 Comandos Disponibles
+
+| Comando                      | Descripción                                           |
+| ---------------------------- | ----------------------------------------------------- |
+| `init`                       | Inicializa un nuevo proyecto (crea `skills.toml`)     |
+| `add <url> --skill <nombre>` | Añade una nueva skill                                 |
+| `list`                       | Lista todas las skills instaladas                     |
+| `update`                     | Actualiza todas las skills desde sus URLs             |
+| `sync --editors <lista>`     | Sincroniza con editores (cursor, antigravity, vscode) |
+
+## 🛠️ Desarrollo Local
+
+```bash
+# Compilar en modo desarrollo
+cargo build
+
+# Ejecutar directamente
+cargo run -- init
+cargo run -- list
+
+# Probar el wrapper NPM
+node bin/run.js init
+```
+
+## 📝 Notas Importantes
+
+- **El binario debe estar en GitHub Releases** antes de que el script de NPM pueda descargarlo
+- **La versión en `scripts/install.js`** debe coincidir con el tag de GitHub
+- **Los nombres de los binarios** deben seguir el formato: `skill-cli-{platform}.exe`
+  - Linux: `skill-cli-linux`
+  - Windows: `skill-cli-win.exe`
+  - macOS: `skill-cli-macos`
+
+## 🤝 Contribuir
+
+**IMPORTANTE:** Este es un proyecto de código propietario. Las contribuciones están sujetas a términos especiales:
+
+1. Todas las contribuciones se considerarán cedidas al titular de los derechos de autor
+2. Al contribuir, aceptas que tu código se licenciará bajo la misma licencia propietaria
+3. No se permite el uso de contribuciones en proyectos competidores
+4. Contacta con el titular de los derechos antes de realizar contribuciones significativas
+
+Para contribuir:
+
+1. Contacta primero para discutir los cambios propuestos
+2. Fork el proyecto (solo para desarrollo autorizado)
+3. Crea una rama para tu feature (`git checkout -b feature/AmazingFeature`)
+4. Commit tus cambios (`git commit -m 'Add some AmazingFeature'`)
+5. Push a la rama (`git push origin feature/AmazingFeature`)
+6. Abre un Pull Request (sujeto a revisión y aceptación de términos)
+
+## 📄 Licencia
+
+**LICENCIA PROPIETARIA - Todos los derechos reservados**
+
+Este software está protegido por derechos de autor y se distribuye bajo una licencia propietaria restrictiva.
+
+**Restricciones principales:**
+
+- ❌ No se permite uso comercial sin licencia
+- ❌ No se permite modificación o redistribución
+- ❌ No se permite ingeniería inversa
+- ✅ Uso personal y no comercial permitido
+
+Para uso comercial o permisos especiales, consulta el archivo `LICENSE` o contacta al titular de los derechos.
+
+Ver el archivo [LICENSE](LICENSE) para los términos completos.

package/bin/run.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+
+const extension = os.platform() === 'win32' ? '.exe' : '';
+const binPath = path.join(__dirname, `skillctl${extension}`);
+
+if (!require('fs').existsSync(binPath)) {
+    console.error('❌ El binario no se encuentra. Intenta ejecutar: npm install --force');
+    process.exit(1);
+}
+
+// Ejecutar el binario y pasarle todos los argumentos
+const child = spawn(binPath, process.argv.slice(2), { stdio: 'inherit' });
+
+child.on('close', (code) => {
+    process.exit(code);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "skillctl", 
+  "version": "0.0.3",
+  "description": "Gestor de Skills para Agentes de IA",
+  "bin": {
+    "skillctl": "./bin/run.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "tar": "^6.2.0" 
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joeldevz/agent-skill.git"
+  },
+  "keywords": ["ai", "skills", "cli", "agents", "cursor", "antigravity"],
+  "author": "Your Name",
+  "license": "PROPRIETARY"
+}

package/scripts/install.js

@@ -0,0 +1,72 @@
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Configuración
+const REPO = "joeldevz/agent-skill";
+const VERSION = "v0.0.3"; // ¡CAMBIA ESTO PARA QUE COINCIDA CON TU TAG DE GITHUB!
+const BIN_NAME = "skillctl";
+
+// Detectar plataforma
+const platform = os.platform(); // 'darwin', 'linux', 'win32'
+const arch = os.arch(); // 'x64', 'arm64'
+
+let urlPlatform = "";
+let extension = "";
+
+if (platform === 'win32') {
+    urlPlatform = 'win';
+    extension = '.exe';
+} else if (platform === 'darwin') {
+    urlPlatform = 'macos';
+} else if (platform === 'linux') {
+    urlPlatform = 'linux';
+} else {
+    console.error('Sistema operativo no soportado');
+    process.exit(1);
+}
+
+// Construir URL de descarga (GitHub Releases)
+const fileName = `${BIN_NAME}-${urlPlatform}${extension}`;
+const downloadUrl = `https://github.com/${REPO}/releases/download/${VERSION}/${fileName}`;
+
+const binDir = path.join(__dirname, '..', 'bin');
+if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir);
+}
+
+const destPath = path.join(binDir, `skillctl${extension}`);
+
+console.log(`⬇️  Descargando ${BIN_NAME} desde: ${downloadUrl}`);
+
+async function download() {
+    try {
+        const response = await axios({
+            method: 'get',
+            url: downloadUrl,
+            responseType: 'stream'
+        });
+
+        const writer = fs.createWriteStream(destPath);
+        response.data.pipe(writer);
+
+        return new Promise((resolve, reject) => {
+            writer.on('finish', () => {
+                // Dar permisos de ejecución en Linux/Mac
+                if (platform !== 'win32') {
+                    fs.chmodSync(destPath, 0o755);
+                }
+                console.log('✅ Instalación completada.');
+                resolve();
+            });
+            writer.on('error', reject);
+        });
+    } catch (error) {
+        console.error('❌ Error descargando el binario. Asegúrate de que la Release exista en GitHub.');
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+
+download();

package/src/main.rs

@@ -0,0 +1,237 @@
+// src/main.rs (Fragmentos clave)
+use clap::{Parser, Subcommand};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+use anyhow::Result;
+
+// --- MODELO DE DATOS (El Manifiesto) ---
+#[derive(Serialize, Deserialize, Debug)]
+struct SkillManifest {
+    version: String,
+    skills: HashMap<String, SkillEntry>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct SkillEntry {
+    url: String,     // URL original del repo
+    branch: String,  // main, master, etc.
+    local_path: String,
+    last_updated: String,
+}
+
+// --- COMANDOS CLI ---
+#[derive(Parser)]
+#[command(name = "skillctl")]
+#[command(about = "Gestor de Skills para Agentes de IA", long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Inicializa un nuevo proyecto de skills
+    Init,
+    /// Añade una nueva skill al proyecto
+    Add { url: String, skill: String },
+    /// Re-descarga todas las skills desde sus URLs originales
+    Update,
+    /// Genera los archivos de configuración para los editores detectados
+    Sync {
+        #[arg(short, long)]
+        editors: Vec<String>, // ej: --editors cursor,antigravity
+    },
+    /// Lista todas las skills instaladas
+    List,
+}
+
+// --- LÓGICA DE UPDATE ---
+fn update_skills() -> Result<()> {
+    let manifest_path = Path::new("skills.toml");
+    if !manifest_path.exists() {
+        println!("❌ No se encontró skills.toml. Usa 'add' primero.");
+        return Ok(());
+    }
+
+    let content = fs::read_to_string(manifest_path)?;
+    let mut manifest: SkillManifest = toml::from_str(&content)?;
+
+    println!("🔄 Buscando actualizaciones para {} skills...", manifest.skills.len());
+
+    for (name, entry) in &manifest.skills {
+        println!("   ⬇️ Actualizando {}...", name);
+        // Reutilizamos la lógica de descarga (download_file)
+        // Aquí podrías comprobar hashes git si quisieras ser muy preciso,
+        // pero re-descargar el RAW file es rápido y efectivo.
+        download_skill_file(&entry.url, &entry.branch, name)?;
+    }
+    
+    // Actualizamos timestamp en el toml (opcional)
+    fs::write(manifest_path, toml::to_string(&manifest)?)?;
+    
+    println!("✅ Todas las skills están al día.");
+    // Auto-ejecutamos sync para reflejar cambios
+    sync_editors(vec!["cursor".to_string(), "antigravity".to_string()])?;
+    
+    Ok(())
+}
+
+// --- LÓGICA DE SYNC MULTI-EDITOR ---
+fn sync_editors(targets: Vec<String>) -> Result<()> {
+    let manifest = load_manifest()?; // Función helper que lee skills.toml
+
+    for editor in targets {
+        match editor.as_str() {
+            "cursor" => generate_cursor_config(&manifest)?,
+            "antigravity" => generate_antigravity_config(&manifest)?,
+            "vscode" => generate_vscode_config(&manifest)?, // Copilot instructions
+            _ => println!("⚠️ Editor desconocido: {}", editor),
+        }
+    }
+    Ok(())
+}
+
+// Generador para Cursor (.cursorrules)
+fn generate_cursor_config(manifest: &SkillManifest) -> Result<()> {
+    let mut instructions = String::from("# Rules generadas por Skill-CLI\n\n");
+    
+    for (name, entry) in &manifest.skills {
+        // Opción A: Referencia al archivo (si el editor sabe leer paths)
+        instructions.push_str(&format!("## Skill: {}\n", name));
+        instructions.push_str(&format!("Reference: .cursor/skills/{}/SKILL.md\n\n", name));
+        
+        // Opción B (Más robusta): Leer el contenido e inyectarlo si es pequeño
+        // let content = fs::read_to_string(&entry.local_path)?;
+        // instructions.push_str(&content);
+    }
+
+    fs::write(".cursorrules", instructions)?;
+    println!("✅ .cursorrules actualizado.");
+    Ok(())
+}
+
+// Generador para Antigravity (.antigravity)
+fn generate_antigravity_config(manifest: &SkillManifest) -> Result<()> {
+    // Supongamos que Antigravity usa JSON o un formato diferente
+    // O tal vez soporta "Symlinks" virtuales.
+    
+    let mut config_lines = Vec::new();
+    config_lines.push("PROJECT_CONTEXT:".to_string());
+
+    for (name, entry) in &manifest.skills {
+        // Imaginemos que Antigravity necesita path absoluto
+        let abs_path = fs::canonicalize(&entry.local_path)?;
+        config_lines.push(format!("  - IMPORT_SKILL: {}", abs_path.display()));
+    }
+
+    fs::write(".antigravity", config_lines.join("\n"))?;
+    println!("✅ .antigravity actualizado.");
+    Ok(())
+}
+
+// Generador para VSCode (.github/copilot-instructions.md)
+fn generate_vscode_config(manifest: &SkillManifest) -> Result<()> {
+    let mut instructions = String::from("# GitHub Copilot Instructions\n\n");
+    
+    for (name, entry) in &manifest.skills {
+        instructions.push_str(&format!("## Skill: {}\n", name));
+        instructions.push_str(&format!("Path: {}\n\n", entry.local_path));
+    }
+
+    fs::create_dir_all(".github")?;
+    fs::write(".github/copilot-instructions.md", instructions)?;
+    println!("✅ .github/copilot-instructions.md actualizado.");
+    Ok(())
+}
+
+// --- LÓGICA DE INIT ---
+fn init_project() -> Result<()> {
+    let manifest_path = Path::new("skills.toml");
+    if manifest_path.exists() {
+        println!("⚠️  El archivo skills.toml ya existe.");
+        return Ok(());
+    }
+
+    let default_content = r#"# Manifiesto de Skills
+version = "1.0"
+
+[skills]
+# Las skills se añadirán aquí automáticamente al usar 'add'
+"#;
+
+    fs::write(manifest_path, default_content)?;
+    
+    // Crear carpetas necesarias
+    fs::create_dir_all(".cursor/skills")?;
+    
+    println!("✅ Proyecto inicializado. Se ha creado 'skills.toml'.");
+    println!("🚀 Prueba ahora: npx skillctl add <url> --skill <nombre>");
+    
+    Ok(())
+}
+
+// --- LÓGICA DE LIST ---
+fn list_skills() -> Result<()> {
+    let manifest_path = Path::new("skills.toml");
+    if !manifest_path.exists() {
+        println!("❌ No se encontró skills.toml. Ejecuta 'skillctl init' primero.");
+        return Ok(());
+    }
+
+    let content = fs::read_to_string(manifest_path)?;
+    let manifest: SkillManifest = toml::from_str(&content)?;
+
+    if manifest.skills.is_empty() {
+        println!("📦 No hay skills instaladas.");
+        println!("💡 Usa 'skillctl add <url> --skill <nombre>' para añadir una.");
+    } else {
+        println!("📦 Skills instaladas ({}):", manifest.skills.len());
+        for (name, entry) in &manifest.skills {
+            println!("  • {} ({})", name, entry.url);
+            println!("    └─ Branch: {} | Path: {}", entry.branch, entry.local_path);
+        }
+    }
+    
+    Ok(())
+}
+
+// --- HELPER: Cargar manifiesto ---
+fn load_manifest() -> Result<SkillManifest> {
+    let manifest_path = Path::new("skills.toml");
+    if !manifest_path.exists() {
+        anyhow::bail!("No se encontró skills.toml. Ejecuta 'skillctl init' primero.");
+    }
+    
+    let content = fs::read_to_string(manifest_path)?;
+    let manifest: SkillManifest = toml::from_str(&content)?;
+    Ok(manifest)
+}
+
+// --- HELPER: Descargar archivo de skill ---
+fn download_skill_file(url: &str, branch: &str, name: &str) -> Result<()> {
+    // Implementación simplificada - aquí iría la lógica real de descarga
+    println!("   ⬇️ Descargando {} desde {} (branch: {})", name, url, branch);
+    // TODO: Implementar descarga real usando reqwest o similar
+    Ok(())
+}
+
+// --- FUNCIÓN PRINCIPAL ---
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    match &cli.command {
+        Commands::Init => init_project()?,
+        Commands::Add { url, skill } => {
+            println!("🔧 Añadiendo skill '{}' desde {}...", skill, url);
+            // Aquí iría la lógica de add_skill(url, skill)
+            println!("⚠️  Comando 'add' aún no implementado completamente.");
+        }
+        Commands::Update => update_skills()?,
+        Commands::Sync { editors } => sync_editors(editors.clone())?,
+        Commands::List => list_skills()?,
+    }
+
+    Ok(())
+}