diff --git a/.claude/skills/README.md b/.claude/skills/README.md new file mode 100644 index 0000000..6552702 --- /dev/null +++ b/.claude/skills/README.md @@ -0,0 +1,120 @@ +# Skills Claude disponibles + +Todos los skills siguen la estructura oficial de Claude Code con archivos `SKILL.md`. + +## Estructura + +``` +.claude/skills/ +├── README.md # Este archivo +├── init-jupyter/SKILL.md # Inicializar proyecto Jupyter +├── init/SKILL.md # Inicializar CLAUDE.md +├── nochanges/SKILL.md # Modo read-only +├── create-skill/SKILL.md # Crear nuevos skills +├── git-branch/SKILL.md # Crear ramas +├── git-push/SKILL.md # Integrar a master +├── git-recovery/SKILL.md # Recuperar repo +├── sync-repos/SKILL.md # Sincronizar con Gitea +├── list-repos/SKILL.md # Listar workspaces +├── cleanup-worktrees/SKILL.md # Limpiar worktrees +├── import-repo/SKILL.md # Importar repos +├── create-repo/SKILL.md # Crear workspace +├── create-issue/SKILL.md # Crear issue +├── fix-issue/SKILL.md # Implementar issue +├── auto-fix/SKILL.md # Auto-implementar issue +├── auto-create/SKILL.md # Auto-crear issue +├── quick-issue/SKILL.md # Issue rápido (TUI) +├── issues-status/SKILL.md # Dashboard de issues +├── parallel-issues/SKILL.md # Plan de ejecución paralela +├── execute-parallel/SKILL.md # Ejecutar plan paralelo +└── sort-issues/SKILL.md # Ordenar issues por deps +``` + +## Skills por categoría + +### Configuración + +| Skill | Descripción | Uso | +|-------|-------------|-----| +| `/init` | Genera CLAUDE.md personalizado | `/init` | +| `/init-jupyter` | Inicializa proyecto Jupyter con MCP | `/init-jupyter [ruta]` | +| `/nochanges` | Modo read-only para conversar | `/nochanges [tema]` | +| `/create-skill` | Crea un nuevo skill | `/create-skill nombre` | + +### Git + +| Skill | Descripción | Uso | +|-------|-------------|-----| +| `/git-branch` | Crea rama issue/* o quick/* | `/git-branch issue 0013 hot-reload` | +| `/git-push` | Integra rama a master y publica | `/git-push` | +| `/git-recovery` | Recupera repo de estados inconsistentes | `/git-recovery [--aggressive]` | + +### Workspace + +| Skill | Descripción | Uso | +|-------|-------------|-----| +| `/sync-repos` | Sincroniza con Gitea | `/sync-repos [--dry-run]` | +| `/list-repos` | Lista workspaces | `/list-repos [--filter x]` | +| `/cleanup-worktrees` | Limpia worktrees | `/cleanup-worktrees NNNN` | +| `/import-repo` | Importa repo existente | `/import-repo` | +| `/create-repo` | Crea nuevo workspace | `/create-repo` | + +### Issues + +| Skill | Descripción | Uso | +|-------|-------------|-----| +| `/create-issue` | Crea issue con confirmación | `/create-issue` | +| `/fix-issue` | Implementa issue completo | `/fix-issue 0013` | +| `/auto-fix` | Implementa sin confirmación | `/auto-fix 0013` | +| `/auto-create` | Crea issue sin confirmación | `/auto-create` | +| `/quick-issue` | Issue rápido desde TUI | `/quick-issue --text "..."` | +| `/issues-status` | Dashboard de issues | `/issues-status [workspace]` | +| `/parallel-issues` | Genera plan paralelo | `/parallel-issues` | +| `/execute-parallel` | Ejecuta plan paralelo | `/execute-parallel` | +| `/sort-issues` | Ordena por dependencias | `/sort-issues` | + +## Diferencia entre Skills y Commands + +Los **skills** reemplazan a los antiguos commands: + +| Aspecto | Commands (obsoleto) | Skills (actual) | +|---------|---------------------|-----------------| +| Ubicación | `.claude/commands/*.md` | `.claude/skills/*/SKILL.md` | +| Invocación "/" | Sí | Sí | +| Invocación automática | No | Sí (configurable) | +| Frontmatter | Básico | Avanzado | + +## Crear nuevos skills + +```bash +/create-skill nombre-del-skill +``` + +## Campos del frontmatter + +```yaml +--- +name: nombre-skill +description: Qué hace y cuándo usarlo +argument-hint: [archivo] [formato] +disable-model-invocation: true # Solo usuario invoca +user-invocable: false # Solo Claude invoca +allowed-tools: Read, Grep, Bash # Sin confirmación +context: fork # Ejecutar en subagente +--- +``` + +## Convenciones + +- **Nombres**: minúsculas con guiones (`code-review`, no `codeReview`) +- **Descripciones**: claras para que Claude sepa cuándo invocar +- **Un skill por tarea**: mantener enfocados +- **Confirmación**: la mayoría tiene `disable-model-invocation: true` + +## Trunk-based development + +Todos los skills siguen: +- **Una rama por tarea**: corta (horas, no días) +- **Merge rápido**: integrar frecuentemente +- **Tests obligatorios**: siempre antes de merge +- **Pure core / Impure shell**: funciones puras en core/, I/O en shell/ diff --git a/.claude/skills/auto-create/SKILL.md b/.claude/skills/auto-create/SKILL.md new file mode 100644 index 0000000..471db22 --- /dev/null +++ b/.claude/skills/auto-create/SKILL.md @@ -0,0 +1,75 @@ +--- +name: auto-create +description: Crea un issue nuevo e integra automáticamente SIN pedir confirmación +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit +--- + +# auto-create + +Crea un issue nuevo y lo integra automáticamente **sin pedir confirmación**. + +## Sintaxis + +```bash +/auto-create +``` + +## Diferencia con /create-issue + +Este comando NO pausa para confirmación. Solicita datos pero integra automáticamente. + +## Flujo + +### 1-7. Crear issue (igual que /create-issue) + +1. Determinar número +2. Solicitar inputs (titulo, descripción) +3. Generar slug +4. Evaluar tamaño +5. Crear desde template +6. Feature flag (si aplica) +7. Actualizar índice + +**Sin confirmación** - continuar directamente. + +### 8. Integración automática + +```bash +git checkout master +git pull --rebase +git checkout -b quick/create-issue- + +# Commit +git add dev/issues/*.md dev/issues/README.md +git commit -m "docs: crear issue -" + +# Si multi-issue, commit de feature flag +git add dev/feature_flags.json +git commit -m "feat: agregar feature flag " + +# Tests (si aplican) +go test -tags goolm ./... + +# Merge +git checkout master +git merge --no-ff quick/create-issue- +git push +git branch -d quick/create-issue- +``` + +### 9. Mostrar resultado + +``` +Issue - creado e integrado automáticamente + +Para implementar: + /fix-issue +``` + +## Convenciones + +- Sin confirmación +- Mismo formato que /create-issue +- Trunk-based con rama quick/ diff --git a/.claude/skills/auto-fix/SKILL.md b/.claude/skills/auto-fix/SKILL.md new file mode 100644 index 0000000..21480ad --- /dev/null +++ b/.claude/skills/auto-fix/SKILL.md @@ -0,0 +1,75 @@ +--- +name: auto-fix +description: Implementa un issue completo automáticamente SIN pedir confirmación +argument-hint: +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit, TodoWrite +--- + +# auto-fix + +Implementa un issue completo automáticamente **sin pedir confirmación** antes de integrar. + +## Sintaxis + +```bash +/auto-fix +/auto-fix - +``` + +## Diferencia con /fix-issue + +Este comando NO pausa para confirmación. Ejecuta todo el flujo automáticamente. + +**Usar cuando:** estés completamente seguro de que el issue puede implementarse automáticamente. + +## Flujo + +### 1-8. Implementar (igual que /fix-issue) + +1. Resolver issue objetivo +2. Leer issue completo +3. Crear rama `issue/-` +4. Planificar con TodoWrite +5. Implementar completo +6. Tests obligatorios +7. Feature flags (si aplica) +8. Cerrar issue + +**Sin confirmación** - continuar directamente. + +### 9. Integración automática + +```bash +git checkout master +git pull --rebase +go test -tags goolm ./... # verificación final +git merge --no-ff issue/- -m "merge: issue/-" +git push +git branch -d issue/- +``` + +### 10. Mostrar resultado + +``` +Issue completado e integrado automáticamente + +Commits integrados: N +Tests: pasando +Issue: movido a completed/ + +NOTA: Integración automática sin confirmación. +``` + +## Convenciones + +- Sin confirmación (diferencia clave) +- Misma calidad que /fix-issue +- STOP si tests fallan + +## Reglas + +- NO pedir confirmación +- MISMA calidad que /fix-issue +- STOP si tests fallan (no integrar código roto) diff --git a/.claude/skills/cleanup-worktrees/SKILL.md b/.claude/skills/cleanup-worktrees/SKILL.md new file mode 100644 index 0000000..e339a79 --- /dev/null +++ b/.claude/skills/cleanup-worktrees/SKILL.md @@ -0,0 +1,74 @@ +--- +name: cleanup-worktrees +description: Limpia worktrees y ramas locales después de merge +argument-hint: | --all +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read +--- + +# cleanup-worktrees + +Elimina worktrees y sus ramas locales asociadas después de haber sido mergeadas. + +## Sintaxis + +```bash +/cleanup-worktrees # Limpiar worktree específico +/cleanup-worktrees --all # Limpiar todos +``` + +## Flujo + +### 1. Validar argumentos + +- Número de issue (4 dígitos): limpiar ese worktree +- `--all`: limpiar todos en `worktrees/` + +### 2. Determinar worktrees a limpiar + +```bash +# Para issue específica +WORKTREE_PATH="worktrees/issue-$ISSUE_NUM" + +# Para --all +find worktrees -maxdepth 1 -type d -name "issue-*" +``` + +### 3. Confirmar con usuario + +``` +Se eliminarán: + - worktrees/issue-0003 (rama: quick/fix-issue-0003) + +¿Continuar? (y/N): +``` + +### 4. Limpiar cada worktree + +Para cada uno: +1. Verificar si rama fue mergeada +2. Si NO mergeada: advertir y preguntar +3. Eliminar worktree: `git worktree remove --force` +4. Eliminar rama: `git branch -D ` + +### 5. Reportar resultado + +``` +Limpieza completada + +Worktrees restantes: + (ninguno) +``` + +## Convenciones + +- Nomenclatura worktrees: `worktrees/issue-NNNN` +- Nomenclatura ramas: `quick/fix-issue-NNNN` +- Confirmación interactiva siempre + +## Reglas + +- SIEMPRE verificar merge antes de eliminar +- NUNCA eliminar sin confirmación +- SIEMPRE usar --force en worktree remove diff --git a/.claude/skills/create-issue/SKILL.md b/.claude/skills/create-issue/SKILL.md new file mode 100644 index 0000000..750f22c --- /dev/null +++ b/.claude/skills/create-issue/SKILL.md @@ -0,0 +1,99 @@ +--- +name: create-issue +description: Crea un issue nuevo en dev/issues/ con confirmación del usuario +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit +--- + +# create-issue + +Crea un issue nuevo con estructura completa. Si es grande, lo desglosa en sub-issues con feature flags. + +## Sintaxis + +```bash +/create-issue +``` + +## Precondiciones + +- [ ] Directorio `dev/issues/` existe +- [ ] Template `.claude/templates/issue.md` existe + +## Flujo + +### 1. Determinar número del issue + +```bash +ls dev/issues/ dev/issues/completed/ | grep -oP '^\d{4}' | sort -rn | head -1 +``` + +Próximo issue = número_más_alto + 1 (formato 4 dígitos) + +### 2. Solicitar inputs + +- `titulo`: título corto y descriptivo +- `descripcion`: objetivo de lo que se quiere lograr +- `dependencias` (opcional): issues de los que depende + +### 3. Generar slug + +Título → lowercase → palabras separadas por guiones → 2-4 palabras + +### 4. Evaluar tamaño + +**Criterios para sub-issues:** +- Toca más de 2 capas (core/ + shell/ + app/) +- Requiere más de 3 fases +- El usuario lo indica + +**Issue simple:** crear un archivo `dev/issues/-.md` + +**Issue grande:** crear SOLO sub-issues `a-`, `b-`, etc. + +### 5. Crear desde template + +Rellenar todas las secciones: +- Metadata, Objetivo, Contexto +- Arquitectura, Patrón pure/impure +- Tareas, Ejemplo de uso +- Criterios de aceptación + +### 6. Feature flag (solo multi-issue) + +Actualizar `dev/feature_flags.json`: +```json +{ + "": { + "enabled": false, + "issue": "", + "description": "..." + } +} +``` + +### 7. Actualizar índice + +En `dev/issues/README.md` agregar fila(s). + +### 8. Mostrar y confirmar + +``` +Issue creado: - + +¿Te parece bien? +- Si es correcto: commit y push automáticamente +- Si necesitas ajustes: edita manualmente +``` + +### 9. Ejecutar /git-push automáticamente + +Si confirma, crear rama `quick/create-issue-` y ejecutar flujo git. + +## Convenciones + +- Numeración continua sin saltos +- Estado inicial: pendiente +- Issues cortos (horas por rama) +- Sub-issues autocontenidos diff --git a/.claude/skills/create-repo/SKILL.md b/.claude/skills/create-repo/SKILL.md new file mode 100644 index 0000000..c23e36b --- /dev/null +++ b/.claude/skills/create-repo/SKILL.md @@ -0,0 +1,73 @@ +--- +name: create-repo +description: Crea un nuevo subrepo en workspaces/ con estructura core/shell/app +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write +--- + +# create-repo + +Crea un nuevo workspace (subrepo) con estructura estándar, repo en Gitea, y registro en BD. + +## Prerequisitos + +- Variables: `GITEA_URL` y `GITEA_TOKEN` +- Feature flag `workspace_commands` habilitado + +## Flujo interactivo + +### 1. Solicitar inputs + +1. **Nombre**: URL-safe (lowercase, alfanumérico, guiones) +2. **Descripción**: texto libre +3. **Tipo**: go, data, etl, api +4. **¿Privado?**: s/n (default: n) + +### 2. Mostrar resumen y confirmar + +``` +Resumen: + Nombre: my-etl-pipeline + Path local: ./workspaces/my-etl-pipeline + Gitea: https://gitea.../my-etl-pipeline + Tipo: etl + Privado: no + +¿Crear repositorio? (s/n): +``` + +### 3. Ejecutar creación + +Usa `app.CreateWorkspaceCommand(config, params)`: +1. Validar nombre +2. Verificar que no existe +3. Crear estructura core/shell/app/ +4. Escribir templates (go.mod, main.go, etc.) +5. git init + configurar usuario +6. Crear repo en Gitea +7. Push inicial +8. Registrar en SQLite + +**Rollback automático** si falla cualquier paso. + +### 4. Mostrar resultado + +``` +Workspace creado: ./workspaces/my-etl-pipeline + +Para trabajar: + cd workspaces/my-etl-pipeline +``` + +## Validación de nombre + +- Solo letras, números y guiones +- No empezar/terminar con guión +- 2-100 caracteres + +## Troubleshooting + +- "nombre inválido": usar solo lowercase, alfanumérico, guiones +- "ya existe": verificar `ls workspaces/` o usar otro nombre +- "error Gitea": verificar GITEA_TOKEN diff --git a/.claude/skills/create-skill/SKILL.md b/.claude/skills/create-skill/SKILL.md new file mode 100644 index 0000000..10db5cf --- /dev/null +++ b/.claude/skills/create-skill/SKILL.md @@ -0,0 +1,141 @@ +--- +name: create-skill +description: Crea un nuevo skill en .claude/skills/ siguiendo la estructura oficial de Claude Code +argument-hint: [nombre] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit +--- + +# create-skill + +Crea un nuevo skill en `.claude/skills/` con archivo `SKILL.md` obligatorio. + +## Sintaxis + +```bash +/create-skill [nombre] +/create-skill code-review +/create-skill deploy +``` + +## Precondiciones + +- [ ] Carpeta `.claude/skills/` existe +- [ ] No existe skill con el mismo nombre +- [ ] Nombre cumple convenciones (minúsculas, guiones) + +## Flujo + +### 1. Validar nombre + +- Solo minúsculas, números y guiones +- No nombres reservados (help, clear, exit) +- Máximo 64 caracteres + +```bash +ls -d .claude/skills/*/ 2>/dev/null | xargs -n1 basename | grep -E "^${nombre}$" +``` + +Si existe, STOP. + +### 2. Solicitar inputs + +- `nombre`: minúsculas y guiones +- `descripcion`: qué hace y cuándo usarlo (1-2 frases) +- `tipo_invocacion`: + - `ambos` (default): usuario y Claude pueden invocar + - `solo_usuario`: solo `/nombre` (`disable-model-invocation: true`) + - `solo_claude`: solo Claude (`user-invocable: false`) +- `argument_hint` (opcional): ej: `[archivo] [formato]` +- `allowed_tools` (opcional): herramientas sin confirmación +- `instrucciones`: contenido del skill + +### 3. Crear carpeta + +```bash +mkdir -p .claude/skills/${nombre} +``` + +### 4. Determinar frontmatter + +| Tipo | disable-model-invocation | user-invocable | +|------|--------------------------|----------------| +| ambos | (omitir) | (omitir) | +| solo_usuario | true | (omitir) | +| solo_claude | (omitir) | false | + +### 5. Generar SKILL.md + +```markdown +--- +name: ${nombre} +description: ${descripcion} +argument-hint: ${argument_hint} +disable-model-invocation: true # solo si tipo = solo_usuario +allowed-tools: ${allowed_tools} +--- + +# ${nombre} + +${instrucciones} +``` + +### 6. Mostrar y confirmar + +``` +Skill creado: ${nombre} +Ubicación: .claude/skills/${nombre}/SKILL.md + +¿Te parece bien? +- Si correcto: commit y push automáticamente +- Si ajustes: edita manualmente antes +``` + +### 7. Ejecutar /git-push + +Si confirma, crear rama `quick/create-skill-${nombre}` e integrar. + +### 8. Verificar disponibilidad + +``` +Skill /${nombre} creado e integrado + +Para usar: + /${nombre} [argumentos] + +Tipo: ${tipo_invocacion} +``` + +## Campos del frontmatter + +| Campo | Descripción | +|-------|-------------| +| name | Nombre del skill | +| description | Qué hace y cuándo usarlo | +| argument-hint | Pista de argumentos | +| disable-model-invocation | true = solo usuario invoca | +| user-invocable | false = solo Claude invoca | +| allowed-tools | Tools sin pedir permiso | +| context | fork = ejecutar en subagente | +| agent | Tipo subagente: Explore, Plan | + +## Variables dinámicas + +| Variable | Descripción | +|----------|-------------| +| $ARGUMENTS | Todos los argumentos | +| $0, $1, $2 | Argumentos posicionales | +| ${CLAUDE_SKILL_DIR} | Ruta del skill | + +## Convenciones + +- Nombres descriptivos con guiones +- Descripciones claras para invocación automática +- Un skill por tarea + +## Reglas + +- Validar nombre antes de crear +- SKILL.md es obligatorio +- Confirmación antes de integrar diff --git a/.claude/skills/execute-parallel/SKILL.md b/.claude/skills/execute-parallel/SKILL.md new file mode 100644 index 0000000..8753ac7 --- /dev/null +++ b/.claude/skills/execute-parallel/SKILL.md @@ -0,0 +1,91 @@ +--- +name: execute-parallel +description: Ejecuta automáticamente issues del plan de ejecución paralela +argument-hint: [--group N] [--sequential] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write +--- + +# execute-parallel + +Ejecuta automáticamente las issues del plan paralelo. Crea worktrees, ejecuta /fix-issue, mergea y limpia. + +## Sintaxis + +```bash +/execute-parallel # Ejecutar TODOS los grupos +/execute-parallel --group 1 # Solo Grupo 1 +/execute-parallel --sequential # Sin paralelismo +``` + +## Flujo + +### 1. Validar precondiciones + +```bash +# Si no existe plan, generarlo automáticamente +if [ ! -f "PARALLEL_EXECUTION_ORDER.md" ]; then + /parallel-issues +fi +``` + +### 2. Parsear argumentos + +- `--group `: ejecutar solo ese grupo +- `--sequential`: ejecutar uno a uno +- Sin args: ejecutar todos los grupos + +### 3. Ejecutar programa Go + +```bash +./cmd/parallel-executor/parallel-executor $ARGS +``` + +El orquestador Go maneja: +- Creación de worktrees +- Ejecución paralela de `/fix-issue` +- Push de cada rama +- Limpieza de worktrees +- Logging en `logs/` + +### 4. Mostrar resumen + +``` +Ejecución completada + +Logs: + - logs/parallel-execution-*.log + - logs/consolidated-summary.txt + +Worktrees restantes: (ninguno) +``` + +### 5. Eliminar plan + +Si exitoso, eliminar `PARALLEL_EXECUTION_ORDER.md`. + +## Arquitectura Go + +``` +cmd/parallel-executor/ +├── main.go # CLI +├── parser.go # Parse plan +├── worktree.go # Git worktrees +├── executor.go # Ejecutar claude +├── logger.go # Logging +└── orchestrator.go # Goroutines +``` + +## Convenciones + +- Logs persistentes por ejecución +- Timeout 30 min por issue +- Limpieza automática de worktrees +- Plan se elimina al completar + +## Reglas + +- SIEMPRE generar plan si no existe +- Solo advertir si hay cambios (no bloquear) +- SIEMPRE limpiar worktrees al terminar diff --git a/.claude/skills/fix-issue/SKILL.md b/.claude/skills/fix-issue/SKILL.md new file mode 100644 index 0000000..63ac54c --- /dev/null +++ b/.claude/skills/fix-issue/SKILL.md @@ -0,0 +1,112 @@ +--- +name: fix-issue +description: Implementa un issue completo de punta a punta con confirmación +argument-hint: +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit, TodoWrite +--- + +# fix-issue + +Ejecuta el flujo completo de implementación/cierre de un issue: crear rama, implementar, testear, cerrar, confirmar, integrar. + +## Sintaxis + +```bash +/fix-issue +/fix-issue - +``` + +## Precondiciones + +- [ ] Directorio `dev/issues/` existe +- [ ] Directorio `dev/issues/completed/` existe +- [ ] Tests configurados +- [ ] Working tree limpio + +## Flujo + +### 1. Resolver issue objetivo + +```bash +ls dev/issues/-*.md +``` + +- Si no existe: STOP "Issue no encontrado" +- Si ya completado: STOP "Issue ya completado" + +### 2. Leer issue completo + +Extraer: objetivo, tareas, arquitectura, patrón pure/impure, tests. + +### 3. Crear rama de trabajo + +```bash +git checkout master +git pull --rebase +git checkout -b issue/- +``` + +### 4. Planificar con TodoWrite + +Crear plan basado en tareas del issue. + +### 5. Implementar completo + +Para cada tarea: +1. Implementar siguiendo patrón pure core / impure shell +2. Compilar frecuentemente: `go build -tags goolm ./...` +3. Crear commits atómicos durante implementación + +### 6. Tests obligatorios + +```bash +go test -tags goolm ./... +``` + +- Pasan: continuar +- Fallan: STOP y corregir + +### 7. Feature flags (si aplica) + +Actualizar `dev/feature_flags.json` si es multi-issue. + +### 8. Cerrar issue + +```bash +mv dev/issues/-.md dev/issues/completed/ +``` + +Actualizar índice en README.md. + +### 9. Mostrar resumen y confirmar + +``` +Issue completado + +Resumen: +- N archivos modificados +- N commits realizados +- Tests: pasando + +¿Integrar a master? +``` + +### 10. Ejecutar /git-push + +Si confirma, ejecutar flujo de integración. + +## Convenciones + +- Implementar TODAS las tareas +- Commits atómicos durante implementación +- Tests obligatorios +- Pure core / impure shell + +## Reglas + +- NO saltear tareas +- NO commits WIP +- SIEMPRE tests antes de cerrar +- Confirmación obligatoria antes de integrar diff --git a/.claude/skills/git-branch/SKILL.md b/.claude/skills/git-branch/SKILL.md new file mode 100644 index 0000000..a6ebec6 --- /dev/null +++ b/.claude/skills/git-branch/SKILL.md @@ -0,0 +1,97 @@ +--- +name: git-branch +description: Crea una rama de trabajo (issue/* o quick/*). Nunca trabajar directamente en master. +argument-hint: +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read +--- + +# git-branch + +Crea una rama de trabajo siguiendo trunk-based development. **Nunca trabajar directamente en master.** + +## Sintaxis + +```bash +/git-branch issue +/git-branch quick +``` + +## Ejemplos + +```bash +/git-branch issue 0013 hot-reload # Crea issue/0013-hot-reload +/git-branch quick fix-typo-readme # Crea quick/fix-typo-readme +``` + +## Precondiciones + +- [ ] Repositorio git válido +- [ ] Branch master existe +- [ ] Working tree limpio (sin cambios pendientes) + +## Flujo + +### 1. Verificar estado del repositorio + +```bash +git branch --show-current +git status --short +``` + +**Si no estamos en master:** `git checkout master` + +**Si hay cambios sin commitear:** STOP y avisar al usuario: +``` +Hay cambios sin commitear. Opciones: +1. Commitear: git add . && git commit -m "mensaje" +2. Stash: git stash +3. Descartar: git reset --hard (peligroso) +``` + +### 2. Actualizar master desde remoto + +```bash +git pull --rebase +``` + +### 3. Crear rama según tipo + +**Para issues:** +```bash +git checkout -b issue/- +``` + +**Para cambios rápidos:** +```bash +git checkout -b quick/ +``` + +### 4. Confirmar creación + +```bash +git branch --show-current +``` + +Informar: +``` +Rama `` creada desde master actualizado + +Cuando termines: + /git-push +``` + +## Convenciones + +- **Formato issue**: `issue/-` (4 dígitos) +- **Formato quick**: `quick/` +- **Ramas cortas**: horas, no días +- **No pushear ramas**: integrar via merge a master +- **No underscores**: solo guiones + +## Reglas + +- NUNCA trabajar directamente en master +- SIEMPRE verificar working tree limpio +- SIEMPRE actualizar master antes de crear rama diff --git a/.claude/skills/git-push/SKILL.md b/.claude/skills/git-push/SKILL.md new file mode 100644 index 0000000..548fba1 --- /dev/null +++ b/.claude/skills/git-push/SKILL.md @@ -0,0 +1,116 @@ +--- +name: git-push +description: Integra cambios a master y publica. Soporta ramas issue/* y quick/*. +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit +--- + +# git-push + +Integra cambios a master y publica al remoto. Detecta automáticamente la rama actual. + +## Sintaxis + +```bash +/git-push +``` + +## Flujo + +### 1. Verificar rama actual y estado + +```bash +git branch --show-current +git status --short +``` + +**Caso A: En rama issue/* o quick/*** - Continuar al paso 2 + +**Caso B: En master con cambios** - Crear rama quick automáticamente: +- Analizar archivos modificados para generar slug +- `git checkout -b quick/` + +**Caso C: En master sin cambios** - STOP: "No hay nada que publicar" + +### 2. Crear commits por bloque lógico + +```bash +git status --short +git diff --stat +``` + +Agrupar cambios por tipo y crear commits atómicos: + +```bash +git add +git commit -m ": " -m "" +``` + +**Tipos:** feat, fix, refactor, docs, chore, test + +**Reglas de commits:** +- No WIP +- No mezclar tipos +- Descripción larga obligatoria en español + +### 3. Ejecutar tests + +```bash +go test -tags goolm ./... +``` + +- Tests pasan: continuar +- Tests fallan: STOP y corregir +- No hay tests: informar y continuar + +### 4. Merge a master + +```bash +git checkout master +git pull --rebase +git merge --no-ff -m "merge: — " +``` + +### 5. Push a remoto + +```bash +git push +``` + +### 6. Limpiar rama local + +```bash +git branch -d +``` + +### 7. Verificación final + +```bash +git log --oneline -3 +``` + +``` +Rama `` integrada a master y publicada + +Commits creados: +- +- merge: + +Rama local eliminada. +``` + +## Convenciones + +- Commits atómicos +- Tests obligatorios antes de merge +- Merge --no-ff siempre +- Push inmediato + +## Reglas + +- NO commits WIP +- NO mezclar tipos en un commit +- NO saltear tests +- NO push --force a master +- SIEMPRE usar --no-ff diff --git a/.claude/skills/git-recovery/SKILL.md b/.claude/skills/git-recovery/SKILL.md new file mode 100644 index 0000000..a28c4a1 --- /dev/null +++ b/.claude/skills/git-recovery/SKILL.md @@ -0,0 +1,105 @@ +--- +name: git-recovery +description: Recupera el repositorio de estados inconsistentes (worktrees huérfanos, branches bloqueados) +argument-hint: [--aggressive] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read +--- + +# git-recovery + +Recupera el repositorio de estados inconsistentes causados por worktrees huérfanos, branches bloqueados o conflictos git. + +## Sintaxis + +```bash +/git-recovery # Recuperación estándar +/git-recovery --aggressive # Limpieza agresiva +``` + +## Cuándo usar + +- Errores "exit status 128" al crear worktrees +- Git reporta "worktree already exists" +- Branches que no se pueden eliminar +- Worktrees huérfanos en `git worktree list` + +## Flujo + +### 1. Diagnóstico inicial + +```bash +git branch --show-current +git status --porcelain +``` + +### 2. Análisis de problemas + +```bash +git worktree list +git branch --list +git remote -v +``` + +### 3. Limpieza de worktrees huérfanos + +```bash +git worktree prune -v +``` + +Si existe directorio `worktrees/`: +- Verificar cada worktree contra `git worktree list` +- Eliminar directorios huérfanos + +### 4. Verificar branches bloqueados + +Para cada branch issue/* o quick/*: +- Si está mergeada: `git branch -d ` +- Si NO está mergeada: advertir + +### 5. Sincronizar con remoto + +```bash +git checkout master +git fetch origin +git pull --rebase origin master +``` + +### 6. Modo agresivo (solo con --aggressive) + +```bash +git remote prune origin -v +git fsck --full +git gc --prune=now +rm -f .git/index.lock # si existe +``` + +### 7. Verificación final + +```bash +git status +git worktree list +git branch --list +``` + +## Patrones de error que activan recovery + +- `exit status 128` +- `worktree .* already exists` +- `reference is not a tree` +- `cannot lock ref` +- `index.lock` + +## Convenciones + +- No destructivo por defecto +- Modo agresivo solo con flag explícito +- Siempre sincroniza con remoto +- Preserva cambios locales + +## Reglas + +- NUNCA git reset --hard sin --aggressive +- NUNCA eliminar branches no mergeadas automáticamente +- SIEMPRE sincronizar con remoto después de limpieza diff --git a/.claude/skills/import-repo/SKILL.md b/.claude/skills/import-repo/SKILL.md new file mode 100644 index 0000000..6f3b603 --- /dev/null +++ b/.claude/skills/import-repo/SKILL.md @@ -0,0 +1,91 @@ +--- +name: import-repo +description: Importa repositorios existentes al sistema Dataforge desde URL remota o local +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write +--- + +# import-repo + +Importa repositorios existentes: desde GitHub/GitLab/Gitea, o adoptando un repo local. + +## Prerequisitos + +- Variables: `GITEA_URL` y `GITEA_TOKEN` +- Feature flag `workspace_commands` habilitado + +## Modos + +### Desde URL remota + +1. Crear repo vacío en Gitea +2. Clonar origen con `git clone --mirror` +3. Push a Gitea con `git push --mirror` +4. Clonar en `workspaces/` +5. Registrar en BD + +### Adoptar repo local + +1. Verificar que existe `.git` +2. Crear repo vacío en Gitea +3. Añadir remote `gitea` +4. Push de branches y tags +5. Registrar en BD + +## Flujo interactivo + +### 1. Solicitar fuente + +``` +Fuente del repositorio: + - URL remota (ej: https://github.com/user/repo) + - Nombre local en workspaces/ (ej: legacy-tool) +``` + +### 2. Detectar modo y analizar + +Usa `core.DetectImportMode(source)` + +### 3. Solicitar nombre de destino + +``` +Nombre en Gitea (Enter para usar 'nombre-sugerido'): +``` + +### 4. Verificar que no existe en Gitea + +### 5. Opciones adicionales + +``` +¿Repositorio privado? (s/N): +Descripción (opcional): +``` + +### 6. Resumen y confirmación + +``` +Resumen: + Fuente: https://... + Destino: gitea.example.com/... + Tipo: importar desde URL remota + +¿Importar? (s/N): +``` + +### 7. Ejecutar importación + +### 8. Mostrar resultado + +``` +Repositorio importado exitosamente. + +Workspace: workspaces/nombre +Gitea URL: https://... +``` + +## Convenciones + +- Confirmación obligatoria +- Rollback automático si falla +- Historia Git siempre preservada diff --git a/.claude/skills/init-jupyter/SKILL.md b/.claude/skills/init-jupyter/SKILL.md new file mode 100644 index 0000000..0f8cb5f --- /dev/null +++ b/.claude/skills/init-jupyter/SKILL.md @@ -0,0 +1,80 @@ +--- +name: init-jupyter +description: Inicializa un proyecto Python con uv, Jupyter Lab y configura MCP para Claude +argument-hint: [ruta-proyecto] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit +--- + +# Inicializar Proyecto Jupyter + +Este skill automatiza la configuración completa de un entorno de análisis de datos con Jupyter Lab integrado con Claude via MCP. + +## Pasos a ejecutar + +1. **Validar ubicación** + - Si se proporciona `$1`, usar esa ruta + - Si no, usar el directorio actual + +2. **Inicializar proyecto con uv** + ```bash + cd [ruta] && uv init + ``` + +3. **Crear entorno virtual** + ```bash + uv venv + ``` + +4. **Instalar dependencias** + ```bash + uv add jupyter jupyter-collaboration + ``` + +5. **Instalar jupyter-mcp-server** + ```bash + uv tool install jupyter-mcp-server + ``` + +6. **Configurar MCP para Claude** + - Crear o actualizar `.claude/settings.local.json` con la configuración del servidor MCP de Jupyter: + ```json + { + "mcpServers": { + "jupyter": { + "command": "jupyter-mcp-server", + "args": [] + } + } + } + ``` + +7. **Crear script de lanzamiento** `start-jupyter.sh`: + ```bash + #!/bin/bash + source .venv/bin/activate + .venv/bin/jupyter lab --no-browser --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.disable_check_xsrf=True + ``` + +8. **Mostrar resumen al usuario** con los comandos para: + - Activar el entorno: `source .venv/bin/activate` + - Lanzar Jupyter: `./start-jupyter.sh` o el comando directo + +## Ejemplos de uso + +**Inicializar en directorio actual:** +```bash +/init-jupyter +``` + +**Inicializar en ruta específica:** +```bash +/init-jupyter ~/proyectos/mi-analisis +``` + +## Notas + +- Si el proyecto ya tiene `pyproject.toml`, preguntar antes de sobrescribir +- El script `start-jupyter.sh` se crea con permisos de ejecución +- La configuración MCP se guarda en `.claude/settings.local.json` del proyecto diff --git a/.claude/skills/init/SKILL.md b/.claude/skills/init/SKILL.md new file mode 100644 index 0000000..b2e44af --- /dev/null +++ b/.claude/skills/init/SKILL.md @@ -0,0 +1,127 @@ +--- +name: init +description: Inicializa configuración de Claude para un repositorio generando CLAUDE.md personalizado +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit, AskUserQuestion +--- + +# init + +Inicializa la configuración de Claude para un repositorio. Solicita información al usuario, analiza la estructura y genera `CLAUDE.md` personalizado. + +## Sintaxis + +```bash +/init +``` + +## Cuándo usar + +- Al configurar Claude Code por primera vez en un repositorio +- Para regenerar instrucciones de Claude +- Después de cambios significativos en arquitectura + +## Precondiciones + +- [ ] Estamos en la raíz de un repositorio git +- [ ] Existe la carpeta `.claude/` + +## Flujo + +### 1. Verificar repo git + +```bash +git rev-parse --is-inside-work-tree +``` + +### 2. Analizar estructura + +```bash +ls -la +ls -la package.json go.mod Cargo.toml pyproject.toml 2>/dev/null +find . -maxdepth 2 -type d -not -path '*/\.*' | head -30 +cat README.md 2>/dev/null | head -50 +``` + +### 3. Solicitar información al usuario + +**Pregunta 1 - Descripción:** +- ¿Qué hace el proyecto? +- ¿Cuál es su propósito? + +**Pregunta 2 - Stack tecnológico:** +- Lenguajes, frameworks +- Base de datos +- Herramientas + +**Pregunta 3 - Convenciones:** +- Estilo de código +- Naming conventions +- Patrones preferidos + +**Pregunta 4 - Flujo de trabajo:** +- Manejo de ramas +- Proceso de PR/review +- Deploy + +**Pregunta 5 - Comandos importantes:** +- Build, test, lint, deploy + +**Pregunta 6 - Restricciones:** +- Archivos que no tocar +- Patrones a evitar + +### 4. Generar CLAUDE.md + +```markdown +# Instrucciones para Claude - [Nombre] + +## Descripción del proyecto +[...] + +## Stack tecnológico +- [...] + +## Estructura del proyecto +[...] + +## Convenciones +### Código +- [...] + +### Git +- [...] + +## Comandos importantes +| Comando | Descripción | +|---------|-------------| +| ... | ... | + +## Restricciones +- [...] +``` + +### 5. Mostrar y confirmar + +``` +He generado CLAUDE.md. ¿Te parece bien? +- Si correcto: commit y push +- Si ajustes: edita y ejecuta /git-push +``` + +### 6. Ejecutar /git-push + +Si confirma, crear rama `quick/init-claude-md` e integrar. + +## Convenciones + +- Preguntar, no asumir +- Priorizar información del usuario +- Estructura clara en CLAUDE.md + +## Reglas + +- SIEMPRE preguntar al usuario +- Confirmar antes de guardar +- No sobrescribir sin avisar diff --git a/.claude/skills/issues-status/SKILL.md b/.claude/skills/issues-status/SKILL.md new file mode 100644 index 0000000..a993f05 --- /dev/null +++ b/.claude/skills/issues-status/SKILL.md @@ -0,0 +1,57 @@ +--- +name: issues-status +description: Dashboard global de issues en todos los workspaces con métricas y filtros +argument-hint: [workspace] [--status pending] [--tag tag] [--export json|csv] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read +--- + +# issues-status + +Muestra dashboard global de todas las issues con métricas, filtros y sugerencias. + +## Sintaxis + +```bash +/issues-status # Dashboard global +/issues-status # Detalle de workspace +/issues-status --status pending # Filtrar por estado +/issues-status --tag backend # Filtrar por tag +/issues-status --export json # Exportar +``` + +## Flujo + +### 1. Parsear argumentos + +- Primer arg (sin --): `filterWorkspace` +- `--status `: pending | in_progress | completed +- `--tag `: filtrar por tag +- `--export `: json | csv + +### 2. Ejecutar dashboard + +Llama `app.IssuesDashboardCommand(config, filterWorkspace, filterStatus, filterTag, exportFormat)` + +### 3. Modo interactivo (dashboard global) + +Si no hay filtros: +1. Mostrar dashboard con sugerencias +2. Preguntar: "¿Ver detalle de un workspace? (nombre o 'n')" +3. Si responde nombre: mostrar detalle +4. Si responde 'n': terminar + +### Comandos sugeridos + +``` +Commands: + /issues-status + /issues-status --status pending + /fix-issue +``` + +## Manejo de errores + +- Si no hay workspaces: sugerir crear o sincronizar +- Si no hay issues: mostrar dashboard vacío con sugerencias diff --git a/.claude/skills/list-repos/SKILL.md b/.claude/skills/list-repos/SKILL.md new file mode 100644 index 0000000..5bb8909 --- /dev/null +++ b/.claude/skills/list-repos/SKILL.md @@ -0,0 +1,64 @@ +--- +name: list-repos +description: Lista todos los workspaces registrados con filtros y ordenamiento +argument-hint: [--filter term] [--sort field] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read +--- + +# list-repos + +Lista todos los workspaces registrados en la base de datos local. + +## Sintaxis + +```bash +/list-repos +/list-repos --filter +/list-repos --sort # name o date +/list-repos --filter etl --sort name +``` + +## Prerequisitos + +- Feature flag `workspace_commands` habilitado +- Base de datos SQLite inicializada + +## Flujo + +### 1. Verificar feature flag + +Si `workspace_commands.enabled: false`, informar y detener. + +### 2. Parsear argumentos + +- `--filter `: filtrar por nombre/descripción (case-insensitive) +- `--sort `: ordenar por `name` o `date` (default: date) + +### 3. Ejecutar listado + +Usa `app.ListWorkspacesCommand(config, filter, sort)`: +1. Obtener workspaces de SQLite +2. Filtrar si hay `--filter` +3. Ordenar según `--sort` +4. Formatear tabla ASCII + +### 4. Mostrar resultado + +``` +Workspaces locales (N repos): + +| Nombre | Descripción | Última act. | Estado | +|--------|-------------|-------------|--------| +| ... | ... | ... | activo | + +URLs Gitea: + - repo1: https://... + - repo2: https://... +``` + +## Troubleshooting + +- "No hay workspaces": Usar `/create-repo` o `/sync-repos` +- "Filtro no encuentra nada": Verificar término o listar sin filtro diff --git a/.claude/skills/nochanges/SKILL.md b/.claude/skills/nochanges/SKILL.md new file mode 100644 index 0000000..d2e3071 --- /dev/null +++ b/.claude/skills/nochanges/SKILL.md @@ -0,0 +1,93 @@ +--- +name: nochanges +description: Modo read-only para conversar, preguntar y opinar sobre el repositorio sin modificar nada +argument-hint: [tema de conversación] +disable-model-invocation: true +user-invocable: true +allowed-tools: Read, Glob, Grep, Task +--- + +# nochanges + +Permite conversar sobre el repositorio en modo **read-only**. Desactiva completamente la escritura. + +## Sintaxis + +```bash +/nochanges [pregunta o tema] +/nochanges # Modo conversación libre +``` + +## Cuándo usar + +- Charlar sobre código sin riesgo de cambios +- Pedir opiniones sobre arquitectura +- Preguntas exploratorias +- Revisar código sin modificar +- Analizar problemas sin aplicar fixes + +## Modo read-only estricto + +**NUNCA usar:** Write, Edit, NotebookEdit, Bash (excepto lectura) + +**SOLO usar:** Read, Glob, Grep, Task (exploratorio) + +**Si el usuario pide cambios:** +``` +Estamos en modo /nochanges (read-only). +Para implementar cambios, sal de este comando y úsame normalmente. +``` + +## Flujo + +### 1. Activar modo read-only + +Recordar que NO se modifican archivos durante toda la sesión. + +### 2. Identificar tema + +Si proporcionó tema: +- Leer archivos relevantes +- Responder basándose en código actual + +Si no proporcionó tema: +- Preguntar: "¿Sobre qué aspecto quieres charlar?" + +### 3. Mantener conversación + +Durante la conversación: +- **Leer** archivos si es necesario +- **Analizar** código existente +- **Opinar** sobre diseño +- **Sugerir** alternativas sin implementar +- **Explicar** conceptos + +**NUNCA:** +- Modificar código +- Crear archivos +- Ejecutar comandos que cambien estado + +### 4. Salida del modo + +Termina cuando: +- Usuario escribe otro comando +- Usuario dice "listo" o "gracias" +- Usuario pide implementar (recordar que salga del modo) + +``` +Conversación read-only completada. +Para implementar algo, úsame normalmente (sin /nochanges). +``` + +## Convenciones + +- Absolutamente ninguna modificación +- Solo herramientas de lectura +- Conversación natural como code review +- Fundamentar opiniones en código real + +## Reglas + +- NUNCA MODIFICAR ARCHIVOS +- Solo herramientas read-only +- Recordar constantemente si piden cambios diff --git a/.claude/skills/parallel-issues/SKILL.md b/.claude/skills/parallel-issues/SKILL.md new file mode 100644 index 0000000..5eec335 --- /dev/null +++ b/.claude/skills/parallel-issues/SKILL.md @@ -0,0 +1,104 @@ +--- +name: parallel-issues +description: Analiza issues y genera plan de ejecución paralela en PARALLEL_EXECUTION_ORDER.md +argument-hint: [--dry-run] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write +--- + +# parallel-issues + +Analiza issues pendientes y genera plan de ejecución paralela agrupando issues independientes. + +## Sintaxis + +```bash +/parallel-issues # Genera archivo +/parallel-issues --dry-run # Solo muestra análisis +``` + +## Cuándo usar + +- Identificar issues paralelizables sin conflictos +- Planificar desarrollo con múltiples worktrees +- Antes de sesiones intensivas de desarrollo + +## Flujo + +### 1. Detectar contexto + +```bash +# Proyecto padre o hijo? +if [[ "$PWD" == *"/workspaces/"* ]]; then + PROJECT_TYPE="child" +else + PROJECT_TYPE="parent" +fi +``` + +### 2. Listar issues pendientes + +```bash +ls -1 dev/issues/*.md | grep -E '[0-9]{4}-.*\.md$' | sort +``` + +Para cada issue extraer: +- Número, título, estado +- Archivos mencionados +- Dependencias explícitas (#NNNN) + +### 3. Analizar conflictos + +**Criterios de conflicto (NO paralelizables):** +- Archivos compartidos +- Dependencias explícitas +- Dependencias transitivas + +### 4. Agrupar por independencia + +Algoritmo de grafos: +- Grupo 1: Issues sin dependencias +- Grupo 2: Issues que dependen solo de Grupo 1 +- etc. + +### 5. Estimar tiempos + +Factores: +- Cantidad de archivos +- Capa afectada (core/shell/app) +- Palabras clave (refactor, fix, nuevo) + +### 6. Generar PARALLEL_EXECUTION_ORDER.md + +```markdown +# Plan de Ejecución Paralela + +## Grupo 1: Issues Independientes +- Issue #0003 - ... +- Issue #0006 - ... + +## Grupo 2: Dependientes de Grupo 1 +- Issue #0004 - depende de #0003 + +## Resumen +| Métrica | Valor | +|---------|-------| +| Ahorro tiempo | 60% | +``` + +### 7. Mostrar resultado + +``` +Plan generado: PARALLEL_EXECUTION_ORDER.md + +Issues analizadas: N +Grupos paralelos: M +Ahorro estimado: X% +``` + +## Convenciones + +- Nombres de grupo: "Grupo N" +- Worktrees: `worktrees/issue-NNNN` +- Estimación en horas (redondeado a .5) diff --git a/.claude/skills/quick-issue/SKILL.md b/.claude/skills/quick-issue/SKILL.md new file mode 100644 index 0000000..228af3b --- /dev/null +++ b/.claude/skills/quick-issue/SKILL.md @@ -0,0 +1,77 @@ +--- +name: quick-issue +description: Crea un issue automáticamente desde TUI con detección automática de número +argument-hint: --text "descripción" +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write, Edit +--- + +# quick-issue + +Crea un issue rápido desde TUI. **No invocar manualmente** - es para uso automático. + +## Sintaxis + +```bash +/quick-issue --text "descripción del issue" +``` + +## Precondiciones + +- [ ] Directorio `dev/issues/` existe +- [ ] Parámetro `--text` proporcionado +- [ ] Working tree limpio + +## Flujo + +### 1. Determinar número + +```bash +ls -1 dev/issues/*.md | grep -E '^dev/issues/[0-9]{4}[a-z]?-' | sort -V +``` + +Siguiente = último número base + 1 (ignorar letras). + +### 2. Generar título y slug + +- Título: usar `--text` directamente +- Slug: convertir a kebab-case + +### 3. Crear archivo de issue + +Template minimalista con: +- Metadata básica +- Objetivo = texto del parámetro +- Tareas a completar con /fix-issue + +### 4. Actualizar índice + +Agregar línea en `dev/issues/README.md`. + +### 5. Crear commits y mergear (sin confirmación) + +```bash +git checkout -b quick/quick-issue-NNNN +git add dev/issues/NNNN-slug.md dev/issues/README.md +git commit -m "docs: crear issue NNNN-slug" +git checkout master +git merge --no-ff quick/quick-issue-NNNN +git push +git branch -d quick/quick-issue-NNNN +``` + +### 6. Reportar resultado + +``` +Issue NNNN-slug creado e integrado + +Para implementar: + /fix-issue NNNN +``` + +## Convenciones + +- Auto-detección de número +- Sin confirmación (flujo automático) +- Template minimalista diff --git a/.claude/skills/sort-issues/SKILL.md b/.claude/skills/sort-issues/SKILL.md new file mode 100644 index 0000000..4b60c57 --- /dev/null +++ b/.claude/skills/sort-issues/SKILL.md @@ -0,0 +1,88 @@ +--- +name: sort-issues +description: Analiza dependencias y genera orden de ejecución óptimo de issues +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write +--- + +# sort-issues + +Analiza issues, construye grafo de dependencias y muestra/genera orden de ejecución recomendado. + +## Sintaxis + +```bash +/sort-issues +``` + +## Flujo + +### 1. Listar issues pendientes + +```bash +ls dev/issues/*.md | grep -E '^dev/issues/[0-9]{4}[a-z]?-.*\.md$' | sort +``` + +### 2. Extraer dependencias de cada issue + +Buscar: +- Tabla "## Dependencias" +- Línea "Bloqueada por" +- Referencias #NNNN + +### 3. Construir grafo y detectar ciclos + +Si hay ciclos: +``` +Dependencias circulares detectadas: + 0010 → 0011 → 0012 → 0010 + +Revisar: +- dev/issues/0010-*.md +- dev/issues/0011-*.md +``` + +### 4. Calcular orden topológico + +Algoritmo Kahn o DFS post-order. + +Desempate: +1. Número menor primero +2. Issues sin deps primero + +### 5. Generar EXECUTION_ORDER.md + +```markdown +# Execution Order + +## Recommended Order +1. #0001 - titulo — razón +2. #0002 - titulo — razón + +## Critical Path +- #0001 → #0002, #0003 + +## Parallelizable Groups +### Group 1 (after #0001) +- #0002 +- #0003 +``` + +### 6. Mostrar resultado + +``` +Orden generado: dev/EXECUTION_ORDER.md + +Issues: N +Camino crítico: #X → #Y → #Z +Grupos paralelos: M + +Próxima issue: #0001 - titulo +``` + +## Convenciones + +- Solo leer issues (no modificar) +- Detectar ambos formatos de dependencias +- Reportar ciclos claramente diff --git a/.claude/skills/sync-repos/SKILL.md b/.claude/skills/sync-repos/SKILL.md new file mode 100644 index 0000000..512ad17 --- /dev/null +++ b/.claude/skills/sync-repos/SKILL.md @@ -0,0 +1,69 @@ +--- +name: sync-repos +description: Sincroniza workspaces locales con repositorios en Gitea +argument-hint: [--dry-run] +disable-model-invocation: true +user-invocable: true +allowed-tools: Bash, Read, Write +--- + +# sync-repos + +Sincroniza workspaces locales con repositorios en Gitea: detecta repos nuevos, clona faltantes, actualiza metadata. + +## Sintaxis + +```bash +/sync-repos # Sincronización con confirmación +/sync-repos --dry-run # Solo análisis, sin cambios +``` + +## Prerequisitos + +- Variables de entorno: `GITEA_URL` y `GITEA_TOKEN` +- Feature flag `workspace_commands` habilitado + +## Flujo + +### 1. Verificar feature flag + +Leer `feature_flags.json`. Si `workspace_commands.enabled: false`, informar y detener. + +### 2. Detectar modo + +- `--dry-run`: solo análisis +- Sin flags: mostrar plan y pedir confirmación + +### 3. Ejecutar análisis + +Usa `app.SyncWorkspacesCommand(config, dryRun)`: +1. Obtener workspaces locales desde SQLite +2. Consultar repos en Gitea +3. Comparar con `core.CompareWorkspaces()` +4. Mostrar plan: ToClone, ToUpdate, Orphans + +### 4. Confirmación interactiva (si no --dry-run) + +``` +¿Ejecutar sincronización? (s/n): +``` + +### 5. Mostrar resultado + +``` +Sincronización completada. + Clonados: N + Actualizados: M + Huérfanos: X +``` + +## Decisiones de diseño + +- Huérfanos NO se eliminan automáticamente +- Confirmación obligatoria antes de clonar +- Clonación secuencial (no paralela) + +## Troubleshooting + +- "GITEA_URL y GITEA_TOKEN requeridos": Configurar variables de entorno +- "error al obtener repositorios": Verificar token y conectividad