Communitygithub.com

tangjuyo/reels-blocker

Executa o plano de implementação processando e executando todas as tarefas definidas em tasks.md.

O que é reels-blocker?

Essa skill automatiza a execução de planos de implementação, lendo e processando um arquivo `tasks.md` que contém uma lista completa de tarefas. Ela é útil para desenvolvedores que desejam um fluxo de trabalho estruturado e disciplinado, garantindo que todas as etapas (desde a configuração inicial até a validação final) sejam seguidas. A skill suporta plataformas como Claude Code, Cursor e Codex (e qualquer agente que suporte skills em modo de comandos). Ela funciona verificando pré-requisitos, analisando checklists de qualidade, preparando arquivos de configuração (como .gitignore, .dockerignore, etc.) e, em seguida, executando as tarefas em fases sequenciais e paralelas, respeitando dependências e aplicando uma abordagem TDD. Por fim, executa hooks de pós-implementação para integração com extensões opcionais e obrigatórias, reportando o status completo ao usuário.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Entrada do Usuário

$ARGUMENTS

Você DEVE considerar a entrada do usuário antes de prosseguir (se não estiver vazia).

Verificações de Pré-Execução

Verificar hooks de extensão (antes da implementação):

  • Verifique se .specify/extensions.yml existe na raiz do projeto.
  • Se existir, leia-o e procure por entradas na chave hooks.before_implement
  • Se o YAML não puder ser analisado ou for inválido, não pule silenciosamente: informe ao usuário que .specify/extensions.yml não pôde ser lido (inclua o erro do analisador) e que nenhum hook foi verificado, incluindo quaisquer hooks obrigatórios (optional: false) registrados lá, então continue normalmente
  • Filtre hooks onde enabled é explicitamente false. Trate hooks sem o campo enabled como habilitados por padrão.
  • Para cada hook restante, não tente interpretar ou avaliar expressões de condition do hook:
    • Se o hook não tem campo condition, ou ele é nulo/vazio, trate o hook como executável
    • Se o hook define uma condition não vazia, pule o hook e deixe a avaliação da condição para a implementação do HookExecutor
  • Ao construir invocações de comando a partir de nomes de comando de hook, substitua pontos (.) por hífens (-). Por exemplo, speckit.git.commit → /speckit-git-commit.
  • Para cada hook executável, produza a seguinte saída com base em sua flag optional:
    • Hook opcional (optional: true):
      ## Extension Hooks
      
      **Hook Opcional**: {extensão}
      Comando: `/{comando}`
      Descrição: {descrição}
      
      Prompt: {prompt}
      Para executar: `/{comando}`
      
    • Hook obrigatório (optional: false):
      ## Extension Hooks
      
      **Hook Automático**: {extensão}
      Executando: `/{comando}`
      EXECUTE_COMMAND: {comando}
      
      Aguarde o resultado do comando do hook antes de prosseguir para o Outline.
      
      Após emitir o bloco acima, você DEVE invocar o hook e aguardar sua conclusão antes de continuar. Execute-o da mesma forma que você executaria o comando neste agente/sessão (a invocação pode diferir do {comando} literal mostrado acima, por exemplo, um agente em modo de skills executa como /skill:speckit-... ou $speckit-...). Apenas emitir o bloco não executa o hook.
  • Se nenhum hook estiver registrado ou .specify/extensions.yml não existir, pule silenciosamente

Outline

  1. Execute .specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks a partir da raiz do repositório e analise as listas FEATURE_DIR e AVAILABLE_DOCS. Todos os caminhos devem ser absolutos. Para aspas simples em argumentos como "I'm Groot", use sintaxe de escape: ex: 'I'''m Groot' (ou aspas duplas se possível: "I'm Groot").

  2. Verificar status dos checklists (se FEATURE_DIR/checklists/ existir):

    • Trate os marcadores de checklist como um portal somente leitura: verifique o estado das caixas de seleção, reporte o status e pergunte antes de prosseguir quando necessário; NÃO modifique arquivos de checklist ou marcadores

    • checklists/requirements.md é o checklist de qualidade de especificação interno mantido por /speckit-specify e /speckit-clarify; checklists personalizados gerados por /speckit-checklist são artefatos de revisão de qualidade de requisitos de propriedade do revisor

    • Para checklists personalizados, [x] significa que o revisor determinou que o critério de qualidade dos requisitos foi satisfeito; NÃO significa que o trabalho de implementação está completo

    • Escaneie todos os arquivos de checklist no diretório checklists/

    • Para cada checklist, conte:

      • Itens totais: Todas as linhas correspondentes a - [ ] ou - [X] ou - [x]
      • Itens marcados: Linhas correspondentes a - [X] ou - [x]
      • Itens não marcados: Linhas correspondentes a - [ ]
    • Crie uma tabela de status:

      | Checklist | Total | Marcados | Não Marcados | Status |
      |-----------|-------|----------|--------------|--------|
      | ux.md     | 12    | 12       | 0            | ✓ PASS |
      | test.md   | 8     | 5        | 3            | ✗ FAIL |
      | security.md | 6   | 6        | 0            | ✓ PASS |
      
    • Calcule o status geral:

      • PASS: Todos os checklists têm 0 itens não marcados
      • FAIL: Um ou mais checklists têm itens não marcados
    • Se algum checklist tiver itens não marcados:

      • Exiba a tabela com as contagens de itens não marcados
      • PARE e pergunte: "Alguns checklists têm itens não marcados. Deseja prosseguir com a implementação mesmo assim? (sim/não)"
      • Aguarde a resposta do usuário antes de continuar
      • Se o usuário disser "não" ou "espere" ou "pare", interrompa a execução
      • Se o usuário disser "sim" ou "prossiga" ou "continue", prossiga para o passo 3
    • Se todos os checklists estiverem marcados:

      • Exiba a tabela mostrando todos os checklists aprovados
      • Prossiga automaticamente para o passo 3
  3. Carregue e analise o contexto de implementação:

    • OBRIGATÓRIO: Leia tasks.md para a lista completa de tarefas e plano de execução
    • OBRIGATÓRIO: Leia plan.md para stack tecnológica, arquitetura e estrutura de arquivos
    • SE EXISTIR: Leia data-model.md para entidades e relacionamentos
    • SE EXISTIR: Leia contracts/ para especificações de API e requisitos de teste
    • SE EXISTIR: Leia research.md para decisões técnicas e restrições
    • SE EXISTIR: Leia .specify/memory/constitution.md para restrições de governança
    • SE EXISTIR: Leia quickstart.md para cenários de integração
  4. Verificação da Configuração do Projeto:

    • OBRIGATÓRIO: Crie/verifique arquivos de ignore com base na configuração real do projeto:

    Lógica de Detecção e Criação:

    • Verifique se o seguinte comando é bem-sucedido para determinar se o repositório é um repositório git (crie/verifique .gitignore se for o caso):

      git rev-parse --git-dir 2>/dev/null
      
    • Verifique se Dockerfile* existe ou Docker em plan.md → crie/verifique .dockerignore

    • Verifique se .eslintrc* existe → crie/verifique .eslintignore

    • Verifique se eslint.config.* existe → garanta que as entradas ignores da configuração cubram os padrões necessários

    • Verifique se .prettierrc* existe → crie/verifique .prettierignore

    • Verifique se .npmrc ou package.json existe → crie/verifique .npmignore (se estiver publicando)

    • Verifique se arquivos terraform (*.tf) existem → crie/verifique .terraformignore

    • Verifique se .helmignore é necessário (gráficos helm presentes) → crie/verifique .helmignore

    Se o arquivo de ignore já existir: Verifique se contém padrões essenciais, anexe padrões críticos ausentes apenas Se o arquivo de ignore estiver ausente: Crie com conjunto completo de padrões para a tecnologia detectada

    Padrões Comuns por Tecnologia (da stack tecnológica em plan.md):

    • 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/
    • Universal: .DS_Store, Thumbs.db, *.tmp, *.swp, .vscode/, .idea/

    Padrões Específicos de Ferramentas:

    • 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. Analise a estrutura de tasks.md e extraia:

    • Fases das tarefas: Setup, Testes, Núcleo, Integração, Polimento
    • Dependências das tarefas: Regras de execução sequencial vs paralela
    • Detalhes das tarefas: ID, descrição, caminhos de arquivos, marcadores paralelos [P]
    • Fluxo de execução: Ordem e requisitos de dependência
  6. Execute a implementação seguindo o plano de tarefas:

    • Execução fase por fase: Complete cada fase antes de passar para a próxima
    • Respeite dependências: Execute tarefas sequenciais em ordem, tarefas paralelas [P] podem ser executadas juntas
    • Siga a abordagem TDD: Execute tarefas de teste antes de suas tarefas de implementação correspondentes
    • Coordenação baseada em arquivos: Tarefas que afetam os mesmos arquivos devem ser executadas sequencialmente
    • Pontos de verificação de validação: Verifique a conclusão de cada fase antes de prosseguir
  7. Regras de execução da implementação:

    • Setup primeiro: Inicialize estrutura do projeto, dependências, configuração
    • Testes antes do código: Se precisar escrever testes para contratos, entidades e cenários de integração
    • Desenvolvimento do núcleo: Implemente modelos, serviços, comandos CLI, endpoints
    • Trabalho de integração: Conexões de banco de dados, middleware, logging, serviços externos
    • Polimento e validação: Testes unitários, otimização de desempenho, documentação
  8. Acompanhamento de progresso e tratamento de erros:

    • Reporte o progresso após cada tarefa concluída
    • Interrompa a execução se qualquer tarefa não paralela falhar
    • Para tarefas paralelas [P], continue com as tarefas bem-sucedidas, reporte as que falharam
    • Forneça mensagens de erro claras com contexto para depuração
    • Sugira próximos passos se a implementação não puder prosseguir
    • IMPORTANTE: Para tarefas concluídas, certifique-se de marcá-las como [X] no arquivo de tarefas.
  9. Validação de conclusão:

    • Verifique se todas as tarefas necessárias foram concluídas
    • Verifique se os recursos implementados correspondem à especificação original
    • Valide se os testes passam e a cobertura atende aos requisitos
    • Confirme se a implementação segue o plano técnico

Nota: Este comando assume que existe uma divisão completa de tarefas em tasks.md. Se as tarefas estiverem incompletas ou ausentes, sugira executar /speckit-tasks primeiro para regenerar a lista de tarefas.

Hooks Obrigatórios de Pós-Execução

Você DEVE completar esta seção antes de reportar a conclusão ao usuário.

Verifique se .specify/extensions.yml existe na raiz do projeto.

  • Se não existir, ou nenhum hook estiver registrado sob a chave hooks.after_implement, pule para o Relatório de Conclusão.
  • Se existir, leia-o e procure por entradas na chave hooks.after_implement.
  • Se o YAML não puder ser analisado ou for inválido, não pule silenciosamente: informe ao usuário que .specify/extensions.yml não pôde ser lido (inclua o erro do analisador) e que nenhum hook foi verificado, incluindo quaisquer hooks obrigatórios (optional: false) registrados lá, então continue para o Relatório de Conclusão.
  • Filtre hooks onde enabled é explicitamente false. Trate hooks sem o campo enabled como habilitados por padrão.
  • Para cada hook restante, não tente interpretar ou avaliar expressões de condition do hook:
    • Se o hook não tem campo condition, ou ele é nulo/vazio, trate o hook como executável
    • Se o hook define uma condition não vazia, pule o hook e deixe a avaliação da condição para a implementação do HookExecutor
  • Ao construir invocações de comando a partir de nomes de comando de hook, substitua pontos (.) por hífens (-). Por exemplo, speckit.git.commit → /speckit-git-commit.
  • Para cada hook executável, produza a seguinte saída com base em sua flag optional:
    • Hook obrigatório (optional: false) — Você DEVE emitir EXECUTE_COMMAND: para cada hook obrigatório:
      ## Extension Hooks
      
      **Hook Automático**: {extensão}
      Executando: `/{comando}`
      EXECUTE_COMMAND: {comando}
      
      Após emitir o bloco acima, você DEVE invocar o hook e aguardar sua conclusão antes de continuar. Execute-o da mesma forma que você executaria o comando neste agente/sessão (a invocação pode diferir do {comando} literal mostrado acima, por exemplo, um agente em modo de skills executa como /skill:speckit-... ou $speckit-...). Apenas emitir o bloco não executa o hook.
    • Hook opcional (optional: true):
      ## Extension Hooks
      
      **Hook Opcional**: {extensão}
      Comando: `/{comando}`
      Descrição: {descrição}
      
      Prompt: {prompt}
      Para executar: `/{comando}`
      

Relatório de Conclusão

Reporte o status final com um resumo do trabalho concluído.

Feito Quando

  • Todas as tarefas em tasks.md concluídas e marcadas como [X]
  • Implementação validada contra especificação, plano e cobertura de testes
  • Hooks de extensão despachados ou ignorados de acordo com as regras em Hooks Obrigatórios de Pós-Execução acima
  • Conclusão reportada ao usuário com resumo do trabalho concluído

Individual skills in this repo

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

Habilidades Relacionadas