Communitygithub.com

tangjuyo/reels-blocker

Ejecuta el plan de implementación procesando y ejecutando todas las tareas definidas en tasks.md.

¿Qué es reels-blocker?

Esta habilidad para agentes de IA (Claude Code, Cursor, Codex) automatiza la implementación de proyectos a partir de un archivo `tasks.md`. Es útil porque garantiza que el agente siga un plan estructurado, respete dependencias entre tareas, verifique listas de verificación de requisitos, configure archivos de ignorados según el stack tecnológico, y ejecute hooks de pre/post-implementación opcionales u obligatorios definidos en `.specify/extensions.yml`. Soporta ejecución secuencial y paralela, enfoque TDD, y reporta el progreso con validación final. El agente comienza evaluando la entrada del usuario, ejecuta hooks opcionales o automáticos, verifica listas de verificación, carga el contexto de implementación (plan.md, tasks.md, data-model.md, etc.), configura archivos como .gitignore, .dockerignore, etc., y finalmente ejecuta las fases del plan (Setup, Tests, Core, Integration, Polish) reportando errores y completitud.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/tangjuyo/reels-blocker/tree/HEAD/.claude/skills/speckit-implement

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Entrada del usuario

$ARGUMENTS

DEBES considerar la entrada del usuario antes de proceder (si no está vacía).

Verificaciones previas a la ejecución

Buscar hooks de extensión (antes de la implementación):

  • Verifica si existe .specify/extensions.yml en la raíz del proyecto.
  • Si existe, léelo y busca entradas bajo la clave hooks.before_implement.
  • Si el YAML no se puede analizar o no es válido, no lo omitas silenciosamente: informa al usuario que no se pudo leer .specify/extensions.yml (incluye el error del analizador) y que no se verificaron hooks, incluidos los hooks obligatorios (optional: false) registrados allí, luego continúa normalmente.
  • Filtra los hooks donde enabled sea explícitamente false. Trata los hooks sin campo enabled como habilitados por defecto.
  • Para cada hook restante, no intentes interpretar ni evaluar las expresiones condition del hook:
    • Si el hook no tiene campo condition, o es nulo/vacío, trata el hook como ejecutable.
    • Si el hook define una condition no vacía, omite el hook y deja la evaluación de la condición a la implementación de HookExecutor.
  • Al construir invocaciones de comandos a partir de nombres de comandos de hooks, reemplaza los puntos (.) con guiones (-). Por ejemplo, speckit.git.commit → /speckit-git-commit.
  • Para cada hook ejecutable, muestra lo siguiente según su bandera optional:
    • Hook opcional (optional: true):
      ## Extension Hooks
      
      **Pre-Hook Opcional**: {extensión}
      Comando: `/{comando}`
      Descripción: {descripción}
      
      Prompt: {prompt}
      Para ejecutar: `/{comando}`
      
    • Hook obligatorio (optional: false):
      ## Extension Hooks
      
      **Pre-Hook Automático**: {extensión}
      Ejecutando: `/{comando}`
      EXECUTE_COMMAND: {comando}
      
      Espera el resultado del comando del hook antes de proceder al Outline.
      
      Después de emitir el bloque anterior, DEBES invocar realmente el hook y esperar a que termine antes de continuar. Ejecútalo de la misma manera en que tú mismo ejecutarías el comando en este agente/sesión (la invocación puede diferir del {comando} literal mostrado arriba; por ejemplo, un agente en modo skills lo ejecuta como /skill:speckit-... o $speckit-...). Solo emitir el bloque no ejecuta el hook.
  • Si no hay hooks registrados o .specify/extensions.yml no existe, omítelo silenciosamente.

Esquema

  1. Ejecuta .specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks desde la raíz del repositorio y analiza la lista FEATURE_DIR y AVAILABLE_DOCS. Todas las rutas deben ser absolutas. Para comillas simples en argumentos como "I'm Groot", usa sintaxis de escape: p.ej. 'I'''m Groot' (o con comillas dobles si es posible: "I'm Groot").

  2. Verificar el estado de las listas de verificación (si existe FEATURE_DIR/checklists/):

    • Trata los marcadores de las listas de verificación como una puerta de solo lectura: escanea el estado de las casillas, reporta el estado y pregunta antes de proceder cuando sea necesario; NO modifiques los archivos ni los marcadores de las listas de verificación.

    • checklists/requirements.md es la lista de verificación de calidad de especificación incorporada, mantenida por /speckit-specify y /speckit-clarify; las listas de verificación personalizadas generadas por /speckit-checklist son artefactos de revisión de calidad de requisitos propiedad del revisor.

    • Para listas de verificación personalizadas, [x] significa que el revisor determinó que se cumple el criterio de calidad de los requisitos; NO significa que el trabajo de implementación esté completo.

    • Escanea todos los archivos de lista de verificación en el directorio checklists/.

    • Para cada lista de verificación, cuenta:

      • Elementos totales: Todas las líneas que coinciden con - [ ] o - [X] o - [x].
      • Elementos marcados: Líneas que coinciden con - [X] o - [x].
      • Elementos sin marcar: Líneas que coinciden con - [ ].
    • Crea una tabla de estado:

      | Lista de Verificación | Total | Marcados | Sin Marcar | Estado |
      |------------------------|-------|----------|------------|--------|
      | ux.md                 | 12    | 12       | 0          | ✓ PASS |
      | test.md               | 8     | 5        | 3          | ✗ FAIL |
      | security.md           | 6     | 6        | 0          | ✓ PASS |
      
    • Calcula el estado general:

      • PASS: Todas las listas de verificación tienen 0 elementos sin marcar.
      • FAIL: Una o más listas de verificación tienen elementos sin marcar.
    • Si alguna lista de verificación tiene elementos sin marcar:

      • Muestra la tabla con los recuentos de elementos sin marcar.
      • DETENTE y pregunta: "Algunas listas de verificación tienen elementos sin marcar. ¿Deseas continuar con la implementación de todos modos? (sí/no)".
      • Espera la respuesta del usuario antes de continuar.
      • Si el usuario dice "no" o "espera" o "detente", detén la ejecución.
      • Si el usuario dice "sí" o "procede" o "continúa", continúa al paso 3.
    • Si todas las listas de verificación están marcadas:

      • Muestra la tabla mostrando que todas las listas de verificación pasaron.
      • Procede automáticamente al paso 3.
  3. Carga y analiza el contexto de implementación:

    • REQUERIDO: Lee tasks.md para obtener la lista completa de tareas y el plan de ejecución.
    • REQUERIDO: Lee plan.md para conocer el stack tecnológico, la arquitectura y la estructura de archivos.
    • SI EXISTE: Lee data-model.md para entidades y relaciones.
    • SI EXISTE: Lee contracts/ para especificaciones de API y requisitos de prueba.
    • SI EXISTE: Lee research.md para decisiones técnicas y restricciones.
    • SI EXISTE: Lee .specify/memory/constitution.md para restricciones de gobernanza.
    • SI EXISTE: Lee quickstart.md para escenarios de integración.
  4. Verificación de configuración del proyecto:

    • REQUERIDO: Crear/verificar archivos de ignorados según la configuración real del proyecto.

    Lógica de detección y creación:

    • Verifica si el siguiente comando tiene éxito para determinar si el repositorio es un repositorio git (crea/verifica .gitignore si es así):

      git rev-parse --git-dir 2>/dev/null
      
    • Verifica si existe Dockerfile* o Docker en plan.md → crea/verifica .dockerignore.

    • Verifica si existe .eslintrc* → crea/verifica .eslintignore.

    • Verifica si existe eslint.config.* → asegúrate de que las entradas ignores de la configuración cubran los patrones requeridos.

    • Verifica si existe .prettierrc* → crea/verifica .prettierignore.

    • Verifica si existe .npmrc o package.json → crea/verifica .npmignore (si se publica).

    • Verifica si existen archivos terraform (*.tf) → crea/verifica .terraformignore.

    • Verifica si se necesita .helmignore (hay charts de helm presentes) → crea/verifica .helmignore.

    Si el archivo de ignorados ya existe: Verifica que contenga patrones esenciales, agrega solo patrones críticos faltantes. Si el archivo de ignorados falta: Créalo con el conjunto completo de patrones para la tecnología detectada.

    Patrones comunes por tecnología (de plan.md stack tecnológico):

    • Node.js/JavaScript/TypeScript: node_modules/, dist/, build/, *.log, .env*
    • Python: __pycache__/, *.pyc, .venv/, venv/, dist/, *.egg-info/
    • Java: target/, *.class, *.jar, .gradle/, build/
    • C#/.NET: bin/, obj/, *.user, *.suo, packages/
    • Go: *.exe, *.test, vendor/, *.out
    • Ruby: .bundle/, log/, tmp/, *.gem, vendor/bundle/
    • PHP: vendor/, *.log, *.cache, *.env
    • Rust: target/, debug/, release/, *.rs.bk, *.rlib, *.prof*, .idea/, *.log, .env*
    • Kotlin: build/, out/, .gradle/, .idea/, *.class, *.jar, *.iml, *.log, .env*
    • C++: build/, bin/, obj/, out/, *.o, *.so, *.a, *.exe, *.dll, .idea/, *.log, .env*
    • C: build/, bin/, obj/, out/, *.o, *.a, *.so, *.exe, *.dll, autom4te.cache/, config.status, config.log, .idea/, *.log, .env*
    • Swift: .build/, DerivedData/, *.swiftpm/, Packages/
    • R: .Rproj.user/, .Rhistory, .RData, .Ruserdata, *.Rproj, packrat/, renv/
    • Universales: .DS_Store, Thumbs.db, *.tmp, *.swp, .vscode/, .idea/

    Patrones específicos de herramientas:

    • Docker: node_modules/, .git/, Dockerfile*, .dockerignore, *.log*, .env*, coverage/
    • ESLint: node_modules/, dist/, build/, coverage/, *.min.js
    • Prettier: node_modules/, dist/, build/, coverage/, package-lock.json, yarn.lock, pnpm-lock.yaml
    • Terraform: .terraform/, *.tfstate*, *.tfvars, .terraform.lock.hcl
    • Kubernetes/k8s: *.secret.yaml, secrets/, .kube/, kubeconfig*, *.key, *.crt
  5. Analiza la estructura de tasks.md y extrae:

    • Fases de tareas: Setup, Tests, Core, Integration, Polish.
    • Dependencias de tareas: Reglas de ejecución secuencial vs paralela.
    • Detalles de tareas: ID, descripción, rutas de archivos, marcadores paralelos [P].
    • Flujo de ejecución: Orden y requisitos de dependencia.
  6. Ejecuta la implementación siguiendo el plan de tareas:

    • Ejecución fase por fase: Completa cada fase antes de pasar a la siguiente.
    • Respeta las dependencias: Ejecuta tareas secuenciales en orden, las tareas paralelas [P] pueden ejecutarse juntas.
    • Sigue el enfoque TDD: Ejecuta tareas de prueba antes que sus tareas de implementación correspondientes.
    • Coordinación basada en archivos: Las tareas que afectan los mismos archivos deben ejecutarse secuencialmente.
    • Puntos de control de validación: Verifica la finalización de cada fase antes de proceder.
  7. Reglas de ejecución de implementación:

    • Configuración primero: Inicializa la estructura del proyecto, dependencias, configuración.
    • Pruebas antes que código: Si necesitas escribir pruebas para contratos, entidades y escenarios de integración.
    • Desarrollo principal: Implementa modelos, servicios, comandos CLI, endpoints.
    • Trabajo de integración: Conexiones de base de datos, middleware, logging, servicios externos.
    • Pulido y validación: Pruebas unitarias, optimización de rendimiento, documentación.
  8. Seguimiento del progreso y manejo de errores:

    • Reporta el progreso después de cada tarea completada.
    • Detén la ejecución si falla alguna tarea no paralela.
    • Para tareas paralelas [P], continúa con las tareas exitosas, reporta las fallidas.
    • Proporciona mensajes de error claros con contexto para la depuración.
    • Sugiere los próximos pasos si la implementación no puede continuar.
    • IMPORTANTE: Para tareas completadas, asegúrate de marcarlas como [X] en el archivo de tareas.
  9. Validación de finalización:

    • Verifica que todas las tareas requeridas estén completadas.
    • Comprueba que las características implementadas coincidan con la especificación original.
    • Valida que las pruebas pasen y la cobertura cumpla con los requisitos.
    • Confirma que la implementación sigue el plan técnico.

Nota: Este comando asume que existe un desglose completo de tareas en tasks.md. Si las tareas están incompletas o faltan, sugiere ejecutar primero /speckit-tasks para regenerar la lista de tareas.

Hooks obligatorios posteriores a la ejecución

DEBES completar esta sección antes de informar la finalización al usuario.

Verifica si existe .specify/extensions.yml en la raíz del proyecto.

  • Si no existe, o no hay hooks registrados bajo hooks.after_implement, salta al Informe de Finalización.
  • Si existe, léelo y busca entradas bajo la clave hooks.after_implement.
  • Si el YAML no se puede analizar o no es válido, no lo omitas silenciosamente: informa al usuario que no se pudo leer .specify/extensions.yml (incluye el error del analizador) y que no se verificaron hooks, incluidos los hooks obligatorios (optional: false) registrados allí, luego continúa al Informe de Finalización.
  • Filtra los hooks donde enabled sea explícitamente false. Trata los hooks sin campo enabled como habilitados por defecto.
  • Para cada hook restante, no intentes interpretar ni evaluar las expresiones condition del hook:
    • Si el hook no tiene campo condition, o es nulo/vacío, trata el hook como ejecutable.
    • Si el hook define una condition no vacía, omite el hook y deja la evaluación de la condición a la implementación de HookExecutor.
  • Al construir invocaciones de comandos a partir de nombres de comandos de hooks, reemplaza los puntos (.) con guiones (-). Por ejemplo, speckit.git.commit → /speckit-git-commit.
  • Para cada hook ejecutable, muestra lo siguiente según su bandera optional:
    • Hook obligatorio (optional: false) — DEBES emitir EXECUTE_COMMAND: para cada hook obligatorio:
      ## Extension Hooks
      
      **Hook Automático**: {extensión}
      Ejecutando: `/{comando}`
      EXECUTE_COMMAND: {comando}
      
      Después de emitir el bloque anterior, DEBES invocar realmente el hook y esperar a que termine antes de continuar. Ejecútalo de la misma manera en que tú mismo ejecutarías el comando en este agente/sesión (la invocación puede diferir del {comando} literal mostrado arriba; por ejemplo, un agente en modo skills lo ejecuta como /skill:speckit-... o $speckit-...). Solo emitir el bloque no ejecuta el hook.
    • Hook opcional (optional: true):
      ## Extension Hooks
      
      **Hook Opcional**: {extensión}
      Comando: `/{comando}`
      Descripción: {descripción}
      
      Prompt: {prompt}
      Para ejecutar: `/{comando}`
      

Informe de Finalización

Reporta el estado final con un resumen del trabajo completado.

Listo Cuando

  • Todas las tareas en tasks.md completadas y marcadas como [X].
  • Implementación validada contra la especificación, el plan y la cobertura de pruebas.
  • Hooks de extensión despachados u omitidos de acuerdo con las reglas en Hooks Obligatorios Posteriores a la Ejecución arriba.
  • Finalización reportada al usuario con resumen del trabajo completado.

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

Skills relacionados