skillctl 0.0.6 → 0.0.7

package/README.md

@@ -1,236 +1,118 @@
-# Skillctl: Agent Skill Manager
+# SkillCtl: The Agent Skill Manager ⬢
 
-Gestor de Skills para Agentes de IA (Cursor, Antigravity, VSCode Copilot)
+**SkillCtl** is the professional standard for managing AI Agent Skills. It allows you to discover, install, and synchronize robust agent behaviors across multiple AI editors (Cursor, Windsurf, Antigravity, VS Code, and more).
 
-## 🚀 Inicio Rápido para Usuarios
+> **Concept**: Think of it as `npm` or `cargo`, but for your AI's brain. Instead of packages, you install **skills**—specialized prompts and instructions that give your agent new capabilities.
 
-### Instalación y Uso
+---
 
-No necesitas instalar nada globalmente. Simplemente usa `npx`:
+## 🚀 Key Features
 
-```bash
-# 1. Inicializar un nuevo proyecto
-npx skillctl init
+- **🛡️ Secure by Design**: Integrity checks (SHA-256) ensure the skills you install are exactly what you expect. No silent changes.
+- **🌐 Universal Compatibility**: One tool to rule them all. Works with:
+  - Cursor (`.cursorrules`)
+  - Windsurf (`.windsurfrules`)
+  - Antigravity (`.agent/`)
+  - VS Code, GitHub Copilot, Cline, Roo, OpenHands, and more.
+- **⚡ Supercharged Workflow**:
+  - `search`: Find skills from the community registry instantly.
+  - `add`: Install skills directly from GitHub URLs.
+  - `list`: Keep track of your installed capabilities.
+- **✨ Zero Config**: Smart defaults that just work.
 
-# 2. Añadir una skill
-npx skillctl add https://github.com/wshobson/agents --skill typescript
+---
 
-# 3. Listar skills instaladas
-npx skillctl list
+## 📦 Installation
 
-# 4. Actualizar todas las skills
-npx skillctl update
-
-# 5. Sincronizar con editores
-npx skillctl sync --editors cursor,antigravity
-```
+You don't need to install anything globally. Run it directly with `npx` (Node.js) or `cargo` (Rust).
 
-## 🔧 Desarrollo: Ciclo de Vida del Proyecto
+### Using Node.js (Recommended)
 
-### 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
+```bash
+npx skillctl init
 ```
 
-### Paso 1: Compilar el Binario Rust
+### Using 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
+cargo install skillctl
+skillctl init
 ```
 
-### 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
+## 📖 Usage Guide
 
-### Paso 3: Probar la Descarga Localmente
+### 1. Initialize your Project
 
-Antes de publicar en NPM, prueba que el script de descarga funciona:
+Sets up the necessary configuration files and detects your AI editor automatically.
 
 ```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
+npx skillctl init
 ```
 
-### Paso 4: Publicar en NPM
+### 2. Discover Capabilities
 
-```bash
-# Login en NPM (primera vez)
-npm login
+Search the decentralized registry for new skills.
 
-# 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
+```bash
+npx skillctl search
 ```
 
-## 🔄 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"`
+> _Select a skill from the list to install it immediately._
 
-2. **Compila y crea el tag:**
+### 3. Add a Skill Manually
 
-   ```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
-   ```
+Install a skill directly from a Git repository or URL.
 
-3. **Crea el Release en GitHub** (o usa GitHub Actions)
-
-4. **Publica en NPM:**
-   ```bash
-   npm publish
-   ```
-
-## 📦 Comandos Disponibles
+```bash
+npx skillctl add <url> --skill <name>
+```
 
-| 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) |
+### 4. Verify Installation
 
-## 🛠️ Desarrollo Local
+See what skills are currently active in your environment.
 
 ```bash
-# Compilar en modo desarrollo
-cargo build
-
-# Ejecutar directamente
-cargo run -- init
-cargo run -- list
-
-# Probar el wrapper NPM
-node bin/run.js init
+npx skillctl list
 ```
 
-## 📝 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`
+### 5. Restore & Sync
 
-## 🤝 Contribuir
+Downloading a project? Restore all skills defined in `skills.json` with a single command.
 
-**IMPORTANTE:** Este es un proyecto de código propietario. Las contribuciones están sujetas a términos especiales:
+```bash
+npx skillctl install
+```
 
-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:
+## 🔧 Architecture
 
-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)
+SkillCtl creates a `.agent/skills` (or editor-specific) directory and injects a reference into your editor's rule file.
 
-## 📄 Licencia
+**Directory Structure:**
 
-**LICENCIA PROPIETARIA - Todos los derechos reservados**
+```
+my-project/
+├── .agent/
+│   ├── skills/
+│   │   └── find-files/
+│   │       └── SKILL.md  <-- The Brain
+│   └── rules/
+│       └── rules.md      <-- The Context Linker
+├── skills.json           <-- Lockfile (Registry & Integrity)
+└── src/
+```
 
-Este software está protegido por derechos de autor y se distribuye bajo una licencia propietaria restrictiva.
+---
 
-**Restricciones principales:**
+## 🤝 Contributing
 
-- ❌ 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
+We welcome contributions to the **Registry**!
+To add your skill, submit a PR to `registry.json` with your skill's details.
 
-Para uso comercial o permisos especiales, consulta el archivo `LICENSE` o contacta al titular de los derechos.
+## 📄 License
 
-Ver el archivo [LICENSE](LICENSE) para los términos completos.
+Proprietary Software. See [LICENSE](LICENSE) for details.
+Built with ❤️ for the AI Engineering Community.

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "skillctl", 
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Gestor de Skills para Agentes de IA",
   "bin": {
     "skillctl": "bin/run.js"
   },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "postinstall": "node scripts/install.js"
   },

package/scripts/install.js

@@ -5,7 +5,7 @@ const os = require('os');
 
 // Configuración
 const REPO = "joeldevz/agent-skill";
-const VERSION = "v0.0.6"; // ¡CAMBIA ESTO PARA QUE COINCIDA CON TU TAG DE GITHUB!
+const VERSION = "v0.0.7"; // ¡CAMBIA ESTO PARA QUE COINCIDA CON TU TAG DE GITHUB!
 const BIN_NAME = "skillctl";
 
 // Detectar plataforma

package/.github/workflows/release.yml

@@ -1,42 +0,0 @@
-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

@@ -1,308 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-[package]
-name = "skillctl"
-version = "0.0.6"
-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.4", features = ["derive"] }
-colored = "2.0"
-anyhow = "1.0"
-reqwest = { version = "0.11", features = ["blocking", "json"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-dialoguer = "0.11"
-
-[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

@@ -1,236 +0,0 @@
-# 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/src/main.rs

@@ -1,227 +0,0 @@
-use clap::{Parser, Subcommand};
-use colored::*;
-use anyhow::{Context, Result};
-use std::fs;
-use std::path::Path;
-use serde::{Deserialize, Serialize};
-use dialoguer::{Select, theme::ColorfulTheme};
-use std::collections::HashMap;
-
-// --- MODELO DE DATOS (JSON) ---
-#[derive(Serialize, Deserialize, Debug)]
-struct SkillConfig {
-    editor: String, // "cursor", "antigravity", "vscode"
-    skills: HashMap<String, SkillEntry>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-struct SkillEntry {
-    url: String,
-    local_path: String,
-}
-
-impl Default for SkillConfig {
-    fn default() -> Self {
-        Self {
-            editor: "cursor".to_string(),
-            skills: HashMap::new(),
-        }
-    }
-}
-
-// --- CLI ARGUMENTS ---
-#[derive(Parser)]
-#[command(name = "skillctl")]
-#[command(version = "1.0.0")]
-#[command(about = "Gestor de Skills tipo Vercel", long_about = None)]
-struct Cli {
-    #[command(subcommand)]
-    command: Commands,
-}
-
-#[derive(Subcommand)]
-enum Commands {
-    /// Inicializa el proyecto y elige editor
-    Init,
-    /// Añade una skill. Uso: skillctl add <URL> --skill <NOMBRE>
-    Add {
-        url: String,
-        /// Nombre de la skill a extraer
-        #[arg(long)] // Esto hace que sea --skill <nombre>
-        skill: String,
-    },
-    /// Instala todas las skills definidas en skills.json
-    Install,
-}
-
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-
-    match &cli.command {
-        Commands::Init => init_project()?,
-        Commands::Add { url, skill } => add_skill(url, skill)?,
-        Commands::Install => install_all()?,
-    }
-    Ok(())
-}
-
-// --- COMANDO: INIT (Interactivo) ---
-fn init_project() -> Result<()> {
-    let config_path = Path::new("skills.json");
-    if config_path.exists() {
-        println!("⚠️  Ya existe 'skills.json'.");
-        return Ok(());
-    }
-
-    println!("{}", "🚀 Inicializando Skill Controller...".bold().cyan());
-
-    // Menú interactivo
-    let editors = vec!["Cursor (.cursor/skills)", "Antigravity (.antigravity)", "VSCode (.vscode)"];
-    let selection = Select::with_theme(&ColorfulTheme::default())
-        .with_prompt("¿Qué editor vas a usar?")
-        .default(0)
-        .items(&editors)
-        .interact()
-        .unwrap();
-
-    let editor_key = match selection {
-        0 => "cursor",
-        1 => "antigravity",
-        _ => "vscode",
-    };
-
-    let config = SkillConfig {
-        editor: editor_key.to_string(),
-        skills: HashMap::new(),
-    };
-
-    save_config(&config)?;
-    
-    // Crear carpeta base según editor
-    let base_dir = get_skills_dir(editor_key);
-    fs::create_dir_all(&base_dir)?;
-
-    println!("✅ Configuración guardada en 'skills.json'. Editor: {}", editor_key.green());
-    Ok(())
-}
-
-// --- COMANDO: ADD ---
-fn add_skill(repo_url: &str, skill_name: &str) -> Result<()> {
-    // 1. Cargar config para saber dónde guardar
-    let mut config = load_config()?;
-    let skills_dir = get_skills_dir(&config.editor);
-
-    println!("{} {}...", "📦 Añadiendo skill:".blue(), skill_name);
-
-    // 2. Lógica de descarga (GitHub Raw)
-    let raw_base = repo_url
-        .replace("github.com", "raw.githubusercontent.com")
-        .trim_end_matches('/')
-        .to_string();
-    
-    // URL: .../main/skills/{nombre}/SKILL.md (Ajustar según estructura real del repo)
-    let target_url = format!("{}/main/skills/{}/SKILL.md", raw_base, skill_name);
-    
-    // 3. Descargar
-    let content = download_file(&target_url)?;
-
-    // 4. Guardar archivo
-    let skill_folder = skills_dir.join(skill_name);
-    fs::create_dir_all(&skill_folder)?;
-    let file_path = skill_folder.join("SKILL.md");
-    fs::write(&file_path, &content)?;
-
-    println!("✅ Skill guardada en: {:?}", file_path);
-
-    // 5. Actualizar JSON
-    config.skills.insert(skill_name.to_string(), SkillEntry {
-        url: repo_url.to_string(),
-        local_path: file_path.to_string_lossy().to_string(),
-    });
-    save_config(&config)?;
-
-    // 6. Actualizar configuración del editor (Integración)
-    update_editor_config(&config.editor, skill_name, &file_path)?;
-
-    Ok(())
-}
-
-// --- COMANDO: INSTALL ---
-fn install_all() -> Result<()> {
-    let config = load_config().context("No se encontró skills.json. Ejecuta 'init' primero.")?;
-    
-    println!("🔄 Restaurando {} skills para {}...", config.skills.len(), config.editor);
-
-    for (name, entry) in &config.skills {
-        // Re-usamos la lógica de add pero sin duplicar entradas en el json
-        // (Aquí simplificado: solo descargamos el archivo de nuevo)
-        
-        let raw_base = entry.url
-            .replace("github.com", "raw.githubusercontent.com")
-            .trim_end_matches('/')
-            .to_string();
-        let target_url = format!("{}/main/skills/{}/SKILL.md", raw_base, name);
-
-        match download_file(&target_url) {
-            Ok(content) => {
-                let path = Path::new(&entry.local_path);
-                if let Some(parent) = path.parent() {
-                    fs::create_dir_all(parent)?;
-                }
-                fs::write(path, content)?;
-                println!(" - ✅ {}", name);
-            },
-            Err(_) => println!(" - ❌ Error descargando {}", name),
-        }
-    }
-    println!("✨ Instalación completada.");
-    Ok(())
-}
-
-// --- HELPERS ---
-
-fn get_skills_dir(editor: &str) -> std::path::PathBuf {
-    match editor {
-        "antigravity" => Path::new(".antigravity/skills").to_path_buf(),
-        "vscode" => Path::new(".vscode/skills").to_path_buf(),
-        _ => Path::new(".cursor/skills").to_path_buf(), // Default
-    }
-}
-
-fn load_config() -> Result<SkillConfig> {
-    let content = fs::read_to_string("skills.json")?;
-    let config: SkillConfig = serde_json::from_str(&content)?;
-    Ok(config)
-}
-
-fn save_config(config: &SkillConfig) -> Result<()> {
-    let content = serde_json::to_string_pretty(config)?;
-    fs::write("skills.json", content)?;
-    Ok(())
-}
-
-fn download_file(url: &str) -> Result<String> {
-    let resp = reqwest::blocking::get(url)?;
-    if !resp.status().is_success() {
-        anyhow::bail!("404 Not Found");
-    }
-    Ok(resp.text()?)
-}
-
-fn update_editor_config(editor: &str, skill_name: &str, path: &Path) -> Result<()> {
-    // Aquí implementas la lógica específica para inyectar en .cursorrules o .antigravity
-    // Ejemplo simple para cursor:
-    if editor == "cursor" {
-        let rule_file = Path::new(".cursorrules");
-        let line = format!("\n# Skill: {}\nReference: {}\n", skill_name, path.display());
-        
-        // Append
-        let mut file = fs::OpenOptions::new()
-            .create(true)
-            .append(true)
-            .open(rule_file)?;
-        use std::io::Write;
-        write!(file, "{}", line)?;
-    }
-    Ok(())
-}