refacil-sdd-ai 1.0.0

package/README.md

@@ -0,0 +1,145 @@
+# refacil-sdd-ai
+
+Metodologia **SDD-AI** (Specification-Driven Development with AI) empaquetada como herramienta CLI.
+
+Instala skills para **Claude Code** y **Cursor** que guian al desarrollador por un flujo estructurado de desarrollo usando **OpenSpec** como base de especificaciones.
+
+## Requisitos
+
+- **Node.js >= 20.19.0** (requerido por OpenSpec)
+- **Claude Code** o **Cursor** instalado
+
+## Instalacion y Setup
+
+```bash
+# 1. Instalar el paquete
+npm install --save-dev refacil-sdd-ai
+
+# 2. Inicializar (copia skills a .claude/ y .cursor/, crea CLAUDE.md y .cursorrules)
+npx refacil-sdd-ai init
+
+# 3. IMPORTANTE: Reiniciar la sesion de Claude Code o Cursor
+#    (las skills nuevas no se detectan hasta reiniciar)
+
+# 4. En Claude Code o Cursor, ejecutar:
+/refacil:setup
+#    Esto hace:
+#    - Verifica Node.js y OpenSpec
+#    - Instala OpenSpec si no esta (npm install -g @fission-ai/openspec@latest)
+#    - Inicializa openspec/ en el repo (openspec init --tools claude,cursor)
+#    - Crea openspec/config.yaml con idioma espanol
+#    - Genera AGENTS.md automaticamente analizando el repo
+```
+
+> **Nota**: `openspec init` tambien instala sus propios comandos (`opsx:*`) en `.claude/` y `.cursor/`. Esto es normal. Los `refacil:*` y `opsx:*` coexisten sin conflicto. El equipo debe usar `refacil:*` como interfaz principal.
+
+## Comandos del CLI
+
+```bash
+npx refacil-sdd-ai init      # Instalar skills y crear configs
+npx refacil-sdd-ai update    # Actualizar skills a la ultima version
+npx refacil-sdd-ai clean     # Eliminar skills del repo
+npx refacil-sdd-ai help      # Ver ayuda
+```
+
+## Skills disponibles
+
+Una vez instalado, estos comandos estan disponibles en Claude Code y Cursor:
+
+| Comando | Descripcion |
+|---------|-------------|
+| `/refacil:setup` | Instalar OpenSpec y generar AGENTS.md para el repo |
+| `/refacil:guide` | Guia interactiva — que comando usar segun lo que necesites |
+| `/refacil:explore` | Explorar el codebase sin hacer cambios |
+| `/refacil:propose` | Crear propuesta de cambio (proposal + specs + design + tasks) |
+| `/refacil:apply` | Implementar las tasks del cambio propuesto |
+| `/refacil:test` | Generar tests unitarios desde los artefactos |
+| `/refacil:verify` | Validar implementacion vs specs |
+| `/refacil:review` | Review con checklist de calidad del equipo |
+| `/refacil:archive` | Archivar cambio completado |
+| `/refacil:bug` | Flujo guiado completo para investigar y corregir bugs |
+
+## Flujos de trabajo
+
+### Feature nuevo
+
+```
+/refacil:propose "descripcion del feature"
+/refacil:apply
+/refacil:test
+/refacil:verify
+/refacil:review
+/refacil:archive
+```
+
+### Bug fix
+
+```
+/refacil:bug "descripcion del error"
+/refacil:review
+```
+
+### Explorar codigo
+
+```
+/refacil:explore "que quiero entender"
+```
+
+## Como funciona
+
+1. **`npx refacil-sdd-ai init`** copia las skills a `.claude/skills/` y `.cursor/skills/`, y crea `CLAUDE.md` + `.cursorrules`
+2. **`/refacil:setup`** (en Claude Code o Cursor) instala OpenSpec, analiza el repo y genera un `AGENTS.md` personalizado
+3. Las demas skills (`propose`, `apply`, `test`, etc.) leen `AGENTS.md` para entender las convenciones del proyecto
+
+```
+npx refacil-sdd-ai init     →  Skills en .claude/ y .cursor/
+                                 CLAUDE.md y .cursorrules creados
+
+/refacil:setup               →  OpenSpec instalado
+                                 AGENTS.md generado (analisis automatico del repo)
+
+/refacil:propose             →  Artefactos en openspec/changes/
+/refacil:apply               →  Codigo implementado
+/refacil:test                →  Tests generados
+/refacil:verify              →  Validacion PASS/FAIL
+/refacil:review              →  Review con checklist
+/refacil:archive             →  Cambio archivado
+```
+
+## Que se instala en tu repo
+
+```
+.claude/skills/refacil-*/    # Skills para Claude Code
+.cursor/skills/refacil-*/    # Skills para Cursor
+CLAUDE.md                    # Config para Claude Code (apunta a AGENTS.md)
+.cursorrules                 # Config para Cursor (apunta a AGENTS.md)
+AGENTS.md                    # Generado por /refacil:setup (NO por el CLI)
+openspec/                    # Generado por /refacil:setup via OpenSpec
+```
+
+## Actualizar
+
+Cuando se publique una nueva version del paquete:
+
+```bash
+npm update refacil-sdd-ai
+npx refacil-sdd-ai update    # Re-copia skills sin tocar AGENTS.md ni configs
+```
+
+## Desinstalar
+
+```bash
+npx refacil-sdd-ai clean     # Elimina skills de .claude/ y .cursor/
+npm uninstall refacil-sdd-ai
+```
+
+## Tecnologias
+
+- [OpenSpec](https://github.com/Fission-AI/OpenSpec) — Framework de especificaciones
+- [AGENTS.md](https://agents.md/) — Estandar universal de instrucciones para IA
+- [Claude Code](https://claude.ai/code) — CLI de Anthropic
+- [Cursor](https://cursor.sh) — IDE con IA
+
+## Licencia
+
+MIT

package/bin/cli.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const SKILLS = [
+  'setup',
+  'guide',
+  'explore',
+  'propose',
+  'apply',
+  'test',
+  'verify',
+  'review',
+  'archive',
+  'bug',
+];
+
+const packageRoot = path.resolve(__dirname, '..');
+const projectRoot = process.cwd();
+
+function copyDir(src, dest) {
+  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);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function installSkills() {
+  let installed = 0;
+
+  for (const skill of SKILLS) {
+    const srcDir = path.join(packageRoot, 'skills', skill);
+    if (!fs.existsSync(srcDir)) continue;
+
+    // Copy to .claude/skills/
+    const claudeDest = path.join(projectRoot, '.claude', 'skills', `refacil-${skill}`);
+    copyDir(srcDir, claudeDest);
+
+    // Copy to .cursor/skills/
+    const cursorDest = path.join(projectRoot, '.cursor', 'skills', `refacil-${skill}`);
+    copyDir(srcDir, cursorDest);
+
+    installed++;
+  }
+
+  return installed;
+}
+
+function createClaudeMd() {
+  const dest = path.join(projectRoot, 'CLAUDE.md');
+  if (fs.existsSync(dest)) {
+    console.log('  CLAUDE.md ya existe, no se sobreescribe.');
+    return false;
+  }
+  const template = fs.readFileSync(path.join(packageRoot, 'templates', 'claude-md.md'), 'utf8');
+  fs.writeFileSync(dest, template);
+  return true;
+}
+
+function createCursorRules() {
+  const dest = path.join(projectRoot, '.cursorrules');
+  if (fs.existsSync(dest)) {
+    console.log('  .cursorrules ya existe, no se sobreescribe.');
+    return false;
+  }
+  const template = fs.readFileSync(path.join(packageRoot, 'templates', 'cursorrules.md'), 'utf8');
+  fs.writeFileSync(dest, template);
+  return true;
+}
+
+function removeSkills() {
+  let removed = 0;
+  for (const skill of SKILLS) {
+    const claudeDir = path.join(projectRoot, '.claude', 'skills', `refacil-${skill}`);
+    const cursorDir = path.join(projectRoot, '.cursor', 'skills', `refacil-${skill}`);
+
+    if (fs.existsSync(claudeDir)) {
+      fs.rmSync(claudeDir, { recursive: true });
+      removed++;
+    }
+    if (fs.existsSync(cursorDir)) {
+      fs.rmSync(cursorDir, { recursive: true });
+    }
+  }
+  return removed;
+}
+
+function checkNodeVersion() {
+  const version = process.version; // e.g. v20.19.5
+  const major = parseInt(version.split('.')[0].replace('v', ''));
+  const minor = parseInt(version.split('.')[1]);
+
+  if (major < 20 || (major === 20 && minor < 19)) {
+    console.log(`\n  ADVERTENCIA: Node.js ${version} detectado.`);
+    console.log('  OpenSpec requiere Node.js >= 20.19.0.');
+    console.log('  Las skills se instalaran pero /refacil:setup podria fallar al instalar OpenSpec.\n');
+    return false;
+  }
+  return true;
+}
+
+// --- Commands ---
+
+function init() {
+  console.log('\n  refacil-sdd-ai: Inicializando metodologia SDD-AI...\n');
+
+  // Check Node version
+  const nodeOk = checkNodeVersion();
+  if (nodeOk) {
+    console.log(`  Node.js ${process.version} OK`);
+  }
+
+  // Install skills
+  const count = installSkills();
+  console.log(`  ${count} skills instaladas en .claude/skills/ y .cursor/skills/`);
+
+  // Create CLAUDE.md
+  if (createClaudeMd()) {
+    console.log('  CLAUDE.md creado');
+  }
+
+  // Create .cursorrules
+  if (createCursorRules()) {
+    console.log('  .cursorrules creado');
+  }
+
+  console.log('\n  Siguientes pasos:\n');
+  console.log('  1. REINICIA tu sesion de Claude Code o Cursor');
+  console.log('     (las skills nuevas no se detectan hasta reiniciar)\n');
+  console.log('  2. Ejecuta: /refacil:setup');
+  console.log('     (instala OpenSpec y genera AGENTS.md para tu proyecto)\n');
+  console.log('  Nota: /refacil:setup tambien instalara los comandos de OpenSpec (opsx:*).');
+  console.log('  Los comandos refacil:* y opsx:* coexisten sin conflicto.');
+  console.log('  El equipo debe usar los refacil:* como interfaz principal.\n');
+}
+
+function update() {
+  console.log('\n  refacil-sdd-ai: Actualizando skills...\n');
+  const count = installSkills();
+  console.log(`  ${count} skills actualizadas en .claude/skills/ y .cursor/skills/`);
+  console.log('  AGENTS.md y configuraciones no fueron modificados.');
+  console.log('\n  REINICIA tu sesion de Claude Code o Cursor para aplicar los cambios.\n');
+}
+
+function clean() {
+  console.log('\n  refacil-sdd-ai: Eliminando skills...\n');
+  const count = removeSkills();
+  console.log(`  ${count} skills eliminadas de .claude/skills/ y .cursor/skills/`);
+  console.log('  AGENTS.md, CLAUDE.md y .cursorrules no fueron eliminados.');
+  console.log('\n  Nota: Los comandos opsx:* de OpenSpec no se eliminan.');
+  console.log('  Para eliminar OpenSpec: rm -rf openspec/ .claude/commands/opsx .cursor/commands/opsx\n');
+}
+
+function help() {
+  console.log(`
+  refacil-sdd-ai — Metodologia SDD-AI con OpenSpec
+
+  Comandos:
+    init      Instala skills en .claude/ y .cursor/, crea CLAUDE.md y .cursorrules
+    update    Re-copia skills (para actualizar a nueva version del paquete)
+    clean     Elimina skills de .claude/ y .cursor/
+    help      Muestra esta ayuda
+
+  Flujo completo:
+    1. npm install --save-dev refacil-sdd-ai
+    2. npx refacil-sdd-ai init
+    3. REINICIAR sesion de Claude Code o Cursor
+    4. Ejecutar: /refacil:setup (instala OpenSpec + genera AGENTS.md)
+
+  Requisitos:
+    - Node.js >= 20.19.0 (requerido por OpenSpec)
+    - Claude Code o Cursor instalado
+  `);
+}
+
+// --- Main ---
+
+const command = process.argv[2] || 'help';
+
+switch (command) {
+  case 'init':
+    init();
+    break;
+  case 'update':
+    update();
+    break;
+  case 'clean':
+    clean();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+    help();
+    break;
+  default:
+    console.error(`  Comando desconocido: ${command}`);
+    help();
+    process.exit(1);
+}

package/config/openspec-config.yaml

@@ -0,0 +1,8 @@
+# OpenSpec Configuration Template — Equipo Refacil
+# Copiar a openspec/config.yaml despues de ejecutar openspec init
+
+# Idioma: español para artefactos, terminos tecnicos en ingles
+language: spanish
+
+# Las skills refacil:* usan la estructura de OpenSpec por debajo
+# No es necesario modificar el schema default (spec-driven)

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "refacil-sdd-ai",
+  "version": "1.0.0",
+  "description": "SDD-AI: Specification-Driven Development with AI — metodologia de desarrollo con IA usando OpenSpec, Claude Code y Cursor",
+  "bin": {
+    "refacil-sdd-ai": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "skills/",
+    "templates/",
+    "config/",
+    "README.md"
+  ],
+  "keywords": [
+    "ai",
+    "development",
+    "methodology",
+    "openspec",
+    "claude-code",
+    "cursor",
+    "sdd",
+    "specification-driven",
+    "testing",
+    "code-review"
+  ],
+  "author": "Refacil",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/skills/apply/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: refacil:apply
+description: Implementar las tasks de un cambio propuesto — escribe codigo siguiendo el plan aprobado en los artefactos de OpenSpec
+user-invocable: true
+---
+
+# refacil:apply — Implementacion
+
+Este comando envuelve la funcionalidad de OpenSpec apply y agrega las convenciones del equipo.
+
+## Antes de empezar
+
+Si existe `AGENTS.md` en la raiz del proyecto, leelo para entender las convenciones, arquitectura y patrones.
+Si NO existe `AGENTS.md`, informa al usuario: "No se encontro AGENTS.md. Ejecuta /refacil:setup para generarlo." y detente.
+
+## Instrucciones
+
+### Paso 1: Delegar a OpenSpec apply
+
+Ejecuta internamente las instrucciones de la skill `openspec-apply-change` que esta instalada en `.claude/skills/openspec-apply-change/SKILL.md` (o `.cursor/skills/openspec-apply-change/SKILL.md`).
+
+Lee esa skill y sigue sus instrucciones pasandole el argumento del usuario: **$ARGUMENTS**
+
+**Indicaciones adicionales durante la implementacion:**
+- Respetar estrictamente las convenciones de `AGENTS.md`
+- No agregar funcionalidad fuera del alcance de las specs
+- No hacer refactors no solicitados en codigo existente
+- Si una task es ambigua, preguntar antes de implementar
+
+### Paso 2: Resumen y siguiente paso (aporte Refacil)
+
+Al terminar la implementacion de OpenSpec, agrega este resumen:
+
+```
+=== Implementacion completada ===
+ Archivos creados: [lista]
+ Archivos modificados: [lista]
+ Tasks completadas: [X/Y]
+
+ Siguientes pasos:
+ 1. /refacil:test — Generar tests unitarios
+ 2. /refacil:verify — Validar implementacion vs specs
+```
+
+## Reglas
+
+- SIEMPRE leer los artefactos completos antes de escribir codigo
+- Si `openspec/changes/` no tiene cambios activos, informar y sugerir `/refacil:propose`

package/skills/archive/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: refacil:archive
+description: Archivar un cambio completado — mueve artefactos a archive y sincroniza specs
+user-invocable: true
+---
+
+# refacil:archive — Archivar Cambio Completado
+
+Este comando envuelve la funcionalidad de OpenSpec archive (que internamente llama a sync-specs) y agrega verificaciones previas del equipo.
+
+## Antes de empezar
+
+Si existe `AGENTS.md` en la raiz del proyecto, leelo para entender las convenciones.
+Si NO existe `AGENTS.md`, informa al usuario: "No se encontro AGENTS.md. Ejecuta /refacil:setup para generarlo." y detente.
+
+## Instrucciones
+
+### Paso 1: Verificaciones previas (aporte Refacil)
+
+Antes de archivar, verifica que el cambio esta realmente completo:
+
+1. **Tasks completadas**: Busca el `tasks.md` del cambio y verifica que todas las tasks tienen checkbox marcado (`[x]`). Si hay tasks sin completar, informa al usuario y pregunta si quiere continuar de todas formas.
+
+2. **Tests pasan**: Ejecuta `npm test` y verifica que pasan. Si hay tests que fallan, informa y pregunta si quiere continuar.
+
+3. **Sin archivos pendientes**: Ejecuta `git status` y verifica si hay cambios sin commitear relacionados al feature. Si los hay, sugiere hacer commit antes de archivar.
+
+Si alguna verificacion falla, informa al usuario pero permite que decida si continuar.
+
+### Paso 2: Delegar a OpenSpec archive
+
+Ejecuta internamente las instrucciones de la skill `openspec-archive-change` que esta instalada en `.claude/skills/openspec-archive-change/SKILL.md` (o `.cursor/skills/openspec-archive-change/SKILL.md`).
+
+Lee esa skill y sigue sus instrucciones pasandole el argumento del usuario: **$ARGUMENTS**
+
+OpenSpec archive internamente:
+- Verifica el estado de los artefactos
+- Ofrece sincronizar delta specs a `openspec/specs/` (via `openspec-sync-specs`)
+- Mueve la carpeta del cambio a `openspec/changes/archive/` (con prefijo de fecha)
+
+**IMPORTANTE**: Cuando OpenSpec pregunte si sincronizar specs, responde **SI**. La sincronizacion de specs es obligatoria en la metodologia Refacil — `openspec/specs/` debe reflejar siempre el estado actual del sistema.
+
+### Paso 3: Verificar sincronizacion (aporte Refacil)
+
+Despues de que OpenSpec archive, verifica que `openspec/specs/` fue actualizada:
+
+1. Revisa si hay archivos nuevos o modificados en `openspec/specs/`
+2. Si la sincronizacion no ocurrio (OpenSpec la salto o fallo), ejecuta manualmente la sincronizacion:
+   - Lee el `specs.md` del cambio archivado
+   - Busca el spec principal relevante en `openspec/specs/`
+   - Si existe, integra los cambios (ADDED → agregar, MODIFIED → actualizar, REMOVED → eliminar)
+   - Si NO existe, crea un spec principal nuevo con nombre descriptivo
+
+El objetivo es que `openspec/specs/` documente como funciona el sistema HOY.
+
+### Paso 4: Confirmar
+
+```
+=== Cambio archivado ===
+ Cambio: [nombre]
+ Ubicacion: openspec/changes/archive/[fecha]-[nombre]/
+ Specs sincronizadas: SI
+ Tests: PASS
+
+ El cambio ha sido completado y archivado exitosamente.
+```
+
+## Reglas
+
+- Siempre verificar completitud antes de archivar
+- La sincronizacion de specs es OBLIGATORIA en la metodologia Refacil
+- No eliminar artefactos, solo moverlos a archive/ para trazabilidad

package/skills/bug/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: refacil:bug
+description: Flujo guiado completo para investigar y corregir bugs — desde la descripcion hasta los tests de regresion
+user-invocable: true
+---
+
+# refacil:bug — Flujo de Bug Fix
+
+Eres un asistente especializado en investigacion y correccion de bugs. Guias al desarrollador por un flujo estructurado paso a paso.
+
+## Contexto
+
+Si existe `AGENTS.md` en la raiz del proyecto, leelo para entender las convenciones, arquitectura y patrones.
+Si NO existe `AGENTS.md`, informa al usuario: "No se encontro AGENTS.md. Ejecuta /refacil:setup para generarlo." y detente.
+
+## Instrucciones
+
+### Paso 1: Describir el bug
+
+Preguntale al usuario (si no lo proporciono en $ARGUMENTS):
+
+1. **Que esta pasando?** — Comportamiento actual (el error)
+2. **Que deberia pasar?** — Comportamiento esperado
+3. **Pasos para reproducir** — Como llegar al error
+4. **Evidencia** — Logs, screenshots, stack traces (pedir que los peguen)
+5. **Desde cuando ocurre?** — Siempre, desde un deploy, desde un cambio especifico
+6. **Severidad** — Critico (bloquea produccion), Alto, Medio, Bajo
+
+### Paso 2: Investigar la causa raiz
+
+Con la informacion del paso 1:
+
+1. **Buscar en el codebase**:
+   - Busca las funciones/archivos mencionados en los logs o stack traces
+   - Busca el flujo de datos del escenario que falla
+   - Revisa commits recientes si el bug es nuevo (`git log --oneline -20`)
+
+2. **Trazar el flujo**:
+   - Desde el punto de entrada (controller/endpoint) hasta donde falla
+   - Identifica cada componente en la cadena
+   - Busca donde se rompe la cadena
+
+3. **Formular hipotesis**:
+   - Presenta al usuario 1-3 hipotesis de causa raiz
+   - Para cada una, muestra el archivo y linea sospechosa
+   - Pide al usuario que confirme o descarte
+
+### Paso 3: Diagnosticar
+
+Una vez confirmada la hipotesis:
+
+1. **Confirmar la causa raiz**: Muestra el codigo exacto que causa el bug
+2. **Explicar por que falla**: Que condicion o caso no esta manejado
+3. **Evaluar impacto**: Que mas podria estar afectado
+
+### Paso 4: Proponer correccion
+
+Presenta la correccion propuesta:
+
+1. **Cambio minimo**: La correccion mas pequeña posible que resuelve el bug
+2. **Archivos a modificar**: Lista con descripcion del cambio
+3. **Riesgos**: Que podria romperse con el fix
+4. **Alternativas**: Si hay mas de una forma de corregirlo
+
+Espera aprobacion del usuario antes de implementar.
+
+### Paso 5: Implementar el fix
+
+Con aprobacion del usuario:
+
+1. Aplica la correccion
+2. Verifica que el cambio es minimo y enfocado
+3. No hacer refactors adicionales
+
+### Paso 6: Tests de regresion
+
+Genera tests que:
+
+1. **Reproducen el bug**: Un test que falla SIN el fix (verifica que el test es valido)
+2. **Verifican el fix**: El mismo test pasa CON el fix
+3. **Verifican no regresion**: Tests del flujo normal siguen pasando
+
+Estructura:
+```typescript
+describe('Bug Fix: [descripcion corta]', () => {
+  it('should [comportamiento correcto] when [condicion que antes fallaba]', () => {
+    // Este test hubiera fallado antes del fix
+  });
+
+  it('should still [comportamiento normal] when [condicion normal]', () => {
+    // Este test verifica que no se rompio nada
+  });
+});
+```
+
+### Paso 7: Verificar
+
+1. Ejecuta `npm test` — todos los tests deben pasar
+2. Muestra resumen del fix
+
+```
+=== Bug Fix Completado ===
+ Bug: [descripcion corta]
+ Causa raiz: [explicacion]
+ Fix: [que se cambio]
+ Archivos modificados: [lista]
+ Tests de regresion: [N] tests agregados
+ npm test: PASS
+
+ Siguientes pasos:
+ 1. /refacil:review — Review del fix (recomendado para bugs criticos)
+ 2. Commit y deploy
+```
+
+### Paso 8 (opcional): Crear artefactos OpenSpec
+
+Si el bug es significativo, preguntar al usuario si quiere documentarlo en OpenSpec:
+- Crear carpeta en `openspec/changes/fix-[nombre]/`
+- Generar proposal.md y specs.md con los detalles del bug y fix
+
+## Reglas
+
+- SIEMPRE investigar antes de proponer una correccion
+- NUNCA implementar sin aprobacion del usuario
+- El fix debe ser MINIMO — no aprovechar para refactorizar
+- Los tests de regresion son OBLIGATORIOS
+- Si el bug es en produccion (critico), priorizar velocidad pero sin saltarse tests
+- Responder en español con terminos tecnicos en ingles

package/skills/explore/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: refacil:explore
+description: Explorar e investigar el codebase antes de hacer cambios — analiza arquitectura, flujos y dependencias sin modificar nada
+user-invocable: true
+---
+
+# refacil:explore — Exploracion del Codebase
+
+Este comando envuelve la funcionalidad de OpenSpec explore y agrega contexto del proyecto.
+
+## Antes de empezar
+
+Si existe `AGENTS.md` en la raiz del proyecto, leelo para entender las convenciones, arquitectura y patrones del repositorio. Usa esa informacion como contexto durante la exploracion.
+
+Si NO existe `AGENTS.md`, informa al usuario: "No se encontro AGENTS.md. Ejecuta /refacil:setup para generarlo." y detente.
+
+## Instrucciones
+
+### Paso 1: Delegar a OpenSpec explore
+
+Ejecuta internamente las instrucciones de la skill `openspec-explore` que esta instalada en `.claude/skills/openspec-explore/SKILL.md` (o `.cursor/skills/openspec-explore/SKILL.md`).
+
+Lee esa skill y sigue sus instrucciones pasandole el argumento del usuario: **$ARGUMENTS**
+
+### Paso 2: Enriquecer con contexto de AGENTS.md
+
+Ademas de lo que OpenSpec explore reporta, agrega:
+- Patrones especificos del proyecto que encontraste en AGENTS.md relevantes a la exploracion
+- Convenciones que el usuario deberia tener en cuenta si planea hacer cambios en esa area
+
+### Paso 3: Recomendar siguiente paso
+
+Al final del reporte, sugiere:
+- Si el usuario quiere hacer un cambio: "Ejecuta `/refacil:propose <descripcion>` para crear una propuesta"
+- Si el usuario quiere investigar mas: "Ejecuta `/refacil:explore <otra pregunta>` para seguir explorando"
+
+## Reglas
+
+- NO modifiques ningun archivo
+- NO generes codigo nuevo
+- Solo lectura e investigacion
+- Responde en español con terminos tecnicos en ingles