@qubiit/lmagent 3.0.1 → 3.0.4

package/.agents/docs/getting-started.md

@@ -1,154 +1,77 @@
-# Guía de Inicio Rápido (Getting Started)
+# 🚀 Getting Started with LMAgent
 
-Bienvenido a **LMAgent**, tu framework para desarrollo asistido por IA. Esta guía te llevará desde cero hasta estar productivo con tus agentes.
+Bienvenido a **LMAgent v3.0.3**, el framework que transforma tu IDE en una agencia de desarrollo de software.
 
-## 1. Instalación
+## 1. Requisitos Previos
+- **Node.js**: v18+ (Requerido para el CLI).
+- **IDE**: Cursor, VSCode, Windsurf o cualquier editor que soporte `.cursorrules` o contexto por archivo.
+- **LLM**: Una key de OpenAI, Anthropic o Google configurada en tu IDE.
 
-### Requisitos previos
-- Python 3.12+
-- Git
-- Un IDE agéntico (Antigravity, Cursor, Windsurf, VS Code + Claude/Copilot)
-- API Keys para tus LLMs (OpenAI, Anthropic, Google)
+## 2. Instalación e Inicialización
 
-### Instalación del CLI
-Para tener el comando `lmagent` disponible en tu terminal:
+### Opción A: Proyecto Nuevo (Recomendado)
+Para empezar un proyecto con toda la estructura lista:
 
-1. Clona el repositorio oficial:
 ```bash
-git clone https://github.com/QuBiit0/lmagent.git
-cd lmagent
-```
-
-2. Instala el paquete en modo editable:
-```bash
-pip install -e .
-```
-
-3. Verifica que funcione:
-```bash
-lmagent --version
-# Debería mostrar: LMAgent v3.0.0
-```
-
-### Opción A: Proyecto Nuevo (Desde Cero)
-```bash
-# 1. Crea el directorio
+# 1. Crea tu directorio
 mkdir mi-nuevo-proyecto
 cd mi-nuevo-proyecto
 
-# 2. Inicializa el framework
-lmagent init
+# 2. Inicializa LMAgent (No requiere instalación global)
+npx @qubiit/lmagent@latest init
 ```
-Esto creará la estructura base y estarás listo para empezar.
 
-### Opción B: Proyecto Existente (Legacy/Brownfield)
-LMAgent es **no-intrusivo**. No tocará tu código fuente, solo agregará una capa de inteligencia.
+### Opción B: Proyecto Existente
+Agrega inteligencia a tu código legacy sin tocar tu código fuente:
 
 ```bash
-# 1. Ve a la raíz de tu proyecto
-cd mi-proyecto-existente
-
-# 2. Inicializa el framework
-lmagent init
+cd mi-proyecto-brownfield
+npx @qubiit/lmagent@latest init
 ```
 
-**¿Qué pasará?**
-- Se creará la carpeta `.agent/` (el cerebro del agente).
-- Se añadirán archivos de configuración para tu IDE (`CLAUDE.md`, `.cursorrules`).
-- **Tu código fuente (`src/`, `app/`, etc.) permanecerá intacto.**
-
-**Recomendación**: Después de inicializar, pídele al agente:
-> "Analiza la estructura de este proyecto y crea un `rules/project.md` con las convenciones que veas."
-
-## 2. Configuración Básica
-
-1. **Variables de Entorno**:
-   Copia el ejemplo y edita tus claves:
-   ```bash
-   cp .env.example .env
-   # Edita .env con tus API KEYS
-   ```
-
-2. **Verifica la instalación**:
-   ```bash
-   lmagent doctor
-   ```
-   Deberías ver "✨ All checks passed!".
+### ¿Qué acaba de pasar?
+El comando `init`:
+1. Creó `.agents/` con la estructura de reglas y configuración.
+2. Copió `AGENTS.md` (El cerebro central) y `CLAUDE.md` (Contexto para LLMs).
+3. Configuró `.gitignore` para no subir archivos basura.
 
-## 3. Tu Primera Tarea con el Agente
+## 3. Instalación de Skills (Bridge)
+Para que tu IDE entienda los skills, necesitas instalarlos localmente:
 
-LMAgent está diseñado para trabajar **contigo** en el chat de tu IDE.
-
-### Paso 1: Entender el Contexto
-Abre el chat y dile al agente:
-> "Hola, soy nuevo en este proyecto. ¿Puedes explicarme la estructura y qué personas tienes disponibles?"
-
-### Paso 2: Activar una Persona
-Si vas a trabajar en backend, activa al experto:
-> "Actúa como @Backend Engineer /dev"
-
-El agente adoptará el rol, conocimientos y reglas de esa persona.
-
-### Paso 3: Ejecutar un Workflow
-Vamos a crear una automatización simple. Dile al agente:
-> "Quiero crear una nueva automatización de n8n. Usa el workflow /new-automation"
-
-El agente:
-1. Leerá `workflows/new-automation.md`
-2. Te guiará paso a paso
-3. Creará los archivos necesarios
-
-## 4. Tu Primer Día: Guía Paso a Paso
-
-Si arrancas de cero, **no escribas código todavía**. Sigue este "script" de conversación con el agente:
-
-### Paso 0: El "Super Prompt" (Opcional pero Recomendado) 🚀
-Si ya tienes la idea clara, no pierdas tiempo chateando.
+```bash
+npx lmagent install
+```
+Selecciona tu IDE (ej. Cursor) y elige **"Instalación Rápida"**.
+Esto creará enlaces simbólicos (o copias) en `.cursor/rules` apuntando a `.agents/skills`.
 
-1. Copia la plantilla de **`templates/project_brief.md`**.
-2. Llénala con tus datos.
-3. Pégala en el chat:
-   > "Hola **/orch**. Aquí está el brief de mi proyecto. Inicia el trabajo."
+---
 
-El Orchestrator leerá todo y asignará tareas al PM y Arquitecto automáticamente.
+## 4. Tu Primer Flujo de Trabajo
 
-### Paso 1: Definir el "QUÉ" (con el Product Manager)
-Activa al PM y cuéntale tu idea abstracta.
-> "Hola **/pm**. Quiero crear una aplicación para gestionar gastos personales que sea muy simple. Ayúdame a definir los requerimientos y un MVP."
+### Paso 1: Define el Proyecto (Memoria)
+Edita `.agents/memory/01-project.md`. Dile al agente quién eres y qué construyes.
+*Ejemplo:*
+> "Este es un SaaS de gestión de gastos para freelancers en Latam."
 
-El agente te hará preguntas. Respóndelas hasta que genere un **PRD** (Product Requirements Document).
+### Paso 2: Activa un Skill
+Abre el chat de tu IDE (Ctrl+L / Cmd+L) y escribe:
+> "Hola `/pm`. Lee la memoria del proyecto y ayúdame a crear las historias de usuario para el Login."
 
-### Paso 2: Definir el "CÓMO" (con el Architect)
-Una vez tengas el PRD (o una idea clara), llama al Arquitecto.
-> "Hola **/arch**. Basado en lo que definimos con el PM, define el stack tecnológico ideal y crea la estructura de carpetas inicial. Crea también un archivo `rules/project.md` con las convenciones."
+El agente detectará `/pm`, leerá las reglas de **Product Manager** y actuará en consecuencia.
 
-### Paso 3: Empezar a Construir (con el Developer)
-Con el plan y las reglas listas, empieza a codear.
-> "Hola **/dev**. Vamos a implementar la estructura base que definió el arquitecto. Empieza por inicializar el proyecto (package.json o pyproject.toml)."
+### Paso 3: Código
+Luego, cambia de sombrero:
+> "Gracias PM. Ahora `/dev`, implementa el Login en Next.js siguiendo las historias de usuario."
 
 ---
 
-## 5. Conceptos Clave
-
-### 🎭 Personas
-Son roles especializados que el agente adopta. Cada uno tiene sus propias instrucciones y "superpoderes".
-- **/pm** - Product Manager (Define QUÉ hacer)
-- **/arch** - Architect (Define CÓMO hacerlo)
-- **/dev** - Backend Dev (Escribe el código)
-- **/qa** - QA Engineer (Escribe los tests)
-- **/prompt** - Prompt Engineer (Diseña la lógica cognitiva)
-
-### 📏 Niveles (Levels)
-Determinan cuánto "pensar" antes de "hacer".
-- **Level 0**: Trivial. Hazlo ya.
-- **Level 2**: Medium. Crea un plan (`implementation_plan.md`) y espera mi OK.
-- **Level 4**: Enterprise. Plan muy detallado, revisión de seguridad, aprobación humana obligatoria.
-
-### 📜 Reglas Proactivas
-El agente lee tus reglas en `.agent/rules/`. Si rompes una regla (ej. "No usar prints"), el agente te corregirá o lo arreglará automáticamente.
+## 5. Comandos Útiles
 
-## 5. Siguientes Pasos
+- `npx lmagent doctor`: Verifica que todo esté bien configurado.
+- `npx lmagent update`: Actualiza tus skills a la última versión.
+- `npx lmagent validate`: (Para creadores) Valida que tus skills custom sigan el estándar.
 
-- Lee la [Guía de Uso Completa](usage-guide.md) para dominar el framework.
-- Explora las [Personas](../personas/) disponibles.
-- Revisa los [Workflows](../workflows/) para automatizar tus tareas repetitivas.
+## 🔗 Referencias
+- [Guía de Uso Completa](usage-guide.md)
+- [Índice de Comandos](commands.md)
+- [Reglas del Sistema](../rules/00-master.md)

package/.agents/docs/how-to-start.md

@@ -1,242 +1,30 @@
-# Cómo Empezar un Proyecto con LMAgent
+# 🤖 Tu Primera Interacción con LMAgent
 
-> **LMAgent Framework v3.0 (SPEC+LM)**
-> 
-> Esta guía explica el proceso automatizado para iniciar un nuevo proyecto.
+Una vez instalado LMAgent, sigue este guión para tu primera sesión de trabajo.
 
----
+## 1. El Check-in Inicial
+Abre el chat de tu IDE y preséntate al sistema.
 
-## 🎯 Resumen del Flujo
+> "Hola. Soy nuevo en este proyecto. Lee `AGENTS.md` y explícame qué roles tengo disponibles."
 
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                    FLUJO AUTOMATIZADO DE INICIO                              │
-│                                                                              │
-│   DESARROLLADOR                           AGENTE DE IA                       │
-│   ─────────────                           ─────────────                       │
-│                                                                              │
-│   1. Crear carpeta del proyecto                                              │
-│         │                                                                    │
-│         ▼                                                                    │
-│   2. Crear PROJECT_KICKOFF.md ──────────┐                                   │
-│      (5-10 minutos)                     │                                   │
-│                                          │                                   │
-│   3. Abrir en IDE agéntico              │                                   │
-│         │                                │                                   │
-│         ▼                               ▼                                   │
-│   ┌─────────────────────────────────────────────────────────────────────┐   │
-│   │                    AUTOMÁTICO (Sin intervención)                     │   │
-│   │                                                                      │   │
-│   │   4. Agente detecta PROJECT_KICKOFF.md                               │   │
-│   │   5. Ejecuta: lmagent init                                          │   │
-│   │   6. Ejecuta: /spec workflow                                         │   │
-│   │   7. Crea: spec.yaml → plan.yaml → tasks.yaml                       │   │
-│   │   8. Implementa código siguiendo tasks                               │   │
-│   │   9. Tests + Documentación                                           │   │
-│   │                                                                      │   │
-│   └─────────────────────────────────────────────────────────────────────┘   │
-│                                                                              │
-│   10. USUARIO: Revisar y aprobar cada fase                                  │
-│                                                                              │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
+El agente leerá su propia configuración y te listará los skills activos.
 
----
+## 2. La Primera Tarea (Ejemplo)
+Supongamos que quieres crear un endpoint de Login.
 
-## 📋 Paso a Paso
+### Paso A: Invoca al Experto
+> "Actúa como `/dev`. Vamos a crear un endpoint de login en Node.js."
 
-### Paso 1: Crear Carpeta del Proyecto
+### Paso B: Dale Contexto
+> "El login debe usar JWT y validar contra una base de datos PostgreSQL. Usa las reglas de `04-security.md`."
 
-```bash
-mkdir mi-nuevo-proyecto
-cd mi-nuevo-proyecto
-```
+### Paso C: Refinamiento
+El agente te mostrará un plan o código.
+> "Eso se ve bien, pero agrega validación de email con Zod."
 
-### Paso 2: Crear PROJECT_KICKOFF.md
+## 3. Comandos Mágicos
+Recuerda estos atajos para el chat:
 
-Copia el template desde el repositorio de LMAgent:
-
-```bash
-# Si tienes LMAgent instalado globalmente:
-lmagent kickoff
-
-# O manualmente, copia el archivo:
-cp /path/to/lmagent/templates/PROJECT_KICKOFF.md ./PROJECT_KICKOFF.md
-```
-
-### Paso 3: Completar el Template (OPCIONAL)
-
-Abre `PROJECT_KICKOFF.md` y tienes DOS opciones:
-
-#### Opción A: Completar manualmente (5-10 minutos)
-Llena las secciones marcadas con `[...]`. Solo necesitas:
-- Nombre del proyecto
-- Descripción en una línea
-- Tipo de proyecto
-- Usuario principal
-- Problema a resolver
-- 2-5 features MUST HAVE
-
-#### Opción B: Dejar que el agente pregunte
-Si no completas el template, el agente detectará que está vacío y te hará las preguntas necesarias en el chat:
-
-```
-Agente: "Detecté que este es un proyecto nuevo. Voy a hacerte 
-        algunas preguntas para entender qué quieres construir."
-        
-        "¿Cómo se llama tu proyecto?"
-        
-Tú:     "NutriTrack AI"
-
-Agente: "En una frase, ¿qué es y para quién?"
-
-Tú:     "App para rastrear nutrición con IA que analiza fotos de comida"
-
-... (5-7 preguntas en total)
-```
-
-### Paso 4: Abrir en tu IDE Agéntico
-
-Abre la carpeta del proyecto en tu IDE favorito:
-
-| IDE | Cómo Abrir |
-|-----|-----------|
-| **Cursor** | `cursor .` |
-| **Claude Code** | `claude .` |
-| **Antigravity** | Abrir carpeta en VS Code + extensión |
-| **Copilot** | Abrir en VS Code |
-
-### Paso 5: El Agente Toma el Control 🤖
-
-Una vez que el IDE agéntico analice tu carpeta, detectará `PROJECT_KICKOFF.md` y comenzará automáticamente:
-
-1. **Detecta Framework** → Inicializa LMAgent
-2. **Lee tu Kickoff** → Entiende el proyecto
-3. **Ejecuta /spec** → Crea especificación formal
-4. **Te muestra spec.yaml** → Pide aprobación
-5. **Diseña arquitectura** → Crea plan.yaml
-6. **Te muestra el plan** → Pide aprobación
-7. **Crea tasks** → Desglose de implementación
-8. **Implementa** → Código real
-
----
-
-## 🔄 Puntos de Aprobación
-
-El agente se detendrá y pedirá tu aprobación en estos puntos:
-
-```
-┌────────────────┐
-│  spec.yaml     │ ← "¿Está bien el alcance y las features?"
-└───────┬────────┘
-        │ ✅ Aprobado
-        ▼
-┌────────────────┐
-│  plan.yaml     │ ← "¿Está bien la arquitectura y el plan?"
-└───────┬────────┘
-        │ ✅ Aprobado
-        ▼
-┌────────────────┐
-│  tasks.yaml    │ ← "¿Puedo empezar a implementar?"
-└───────┬────────┘
-        │ ✅ Aprobado
-        ▼
-  🚀 IMPLEMENTACIÓN
-```
-
----
-
-## 📂 Estructura Final del Proyecto
-
-Después del proceso, tu proyecto tendrá esta estructura:
-
-```
-mi-nuevo-proyecto/
-├── PROJECT_KICKOFF.md     # Tu input original
-├── AGENTS.md              # Main entry point de LMAgent
-├── .lmagent               # Marker del framework
-├── README.md              # Generado automáticamente
-│
-├── specs/
-│   └── mi-nuevo-proyecto/
-│       ├── spec.yaml      # Especificación formal
-│       ├── plan.yaml      # Plan de arquitectura
-│       └── tasks.yaml     # Tasks desglosadas
-│
-├── src/                   # Código fuente
-│   ├── app/              
-│   ├── services/
-│   └── ...
-│
-├── tests/                 # Tests automatizados
-│
-├── docs/                  # Documentación
-│   └── adr/               # Architecture Decision Records
-│
-├── docker-compose.yml     # Si aplica
-└── pyproject.toml         # O package.json
-```
-
----
-
-## ⚡ Comandos Útiles
-
-Una vez que el proyecto está inicializado:
-
-| Comando | Qué Hace |
-|---------|----------|
-| `/spec status` | Ver estado del spec actual |
-| `/spec validate` | Validar implementación vs spec |
-| `/pm` | Activar Product Manager para cambios de requisitos |
-| `/arch` | Activar Architect para decisiones técnicas |
-| `/dev` | Activar Developer para implementar |
-| `/qa` | Activar QA para testing |
-
----
-
-## ❓ FAQ
-
-### ¿Qué pasa si quiero cambiar algo después?
-
-Simplemente dile al agente:
-```
-"Quiero agregar feature X al proyecto"
-```
-El agente actualizará spec.yaml y te pedirá aprobación.
-
-### ¿Puedo usar LMAgent en un proyecto existente?
-
-Sí, ejecuta:
-```bash
-cd mi-proyecto-existente
-lmagent init
-```
-Luego crea un PROJECT_KICKOFF.md describiendo lo que quieres agregar.
-
-### ¿Qué IDEs son compatibles?
-
-- ✅ Cursor
-- ✅ Claude Code
-- ✅ Antigravity (VS Code)
-- ✅ GitHub Copilot
-- ✅ Windsurf
-- ✅ Roo Code
-
----
-
-## 🎬 Video Demo (Conceptual)
-
-```
-00:00 - Crear carpeta y PROJECT_KICKOFF.md
-00:05 - Completar template (fast-forward)
-00:15 - Abrir en Cursor
-00:20 - Agente detecta y comienza
-00:30 - spec.yaml generado, revisión
-00:40 - plan.yaml generado, revisión
-00:50 - Implementación automática
-02:00 - Proyecto MVP funcionando 🎉
-```
-
----
-
-*LMAgent v3.0.0 (SPEC+LM) - Build More, Automate Dreams* 🚀
+- **`/orch`**: "Estoy perdido, ayúdame a empezar".
+- **`/test`**: "Crea tests para este archivo".
+- **`/fix`**: "Arregla este error que veo en la terminal".