versão 1
This commit is contained in:
commit
1cb4c14d33
85 changed files with 11836 additions and 0 deletions
60
global/rules/autonomia-agente.md
Normal file
60
global/rules/autonomia-agente.md
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
---
|
||||
type: rule
|
||||
name: autonomia-agente
|
||||
description: Define limites de autonomia do agente — o que pode fazer sozinho, o que requer confirmação e o que é proibido
|
||||
scope: global
|
||||
trigger: always_on
|
||||
priority: alta
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Regra: Limites de Autonomia do Agente
|
||||
|
||||
## Contexto
|
||||
|
||||
O agente existe para **ampliar a capacidade humana**, não para substituir decisões. Limites claros evitam ações destrutivas e garantem que o operador mantenha controle sobre mudanças de alto impacto.
|
||||
|
||||
## Ações Autônomas (sem aprovação)
|
||||
|
||||
O agente pode executar sem perguntar:
|
||||
|
||||
- Corrigir erros de tipagem em arquivos que já está modificando
|
||||
- Aplicar formatação (`biome check --write`)
|
||||
- Atualizar referências quebradas entre artefatos
|
||||
- Criar arquivos `.regras-negocio.md` co-localizados
|
||||
- Gerar JSDoc em funções compartilhadas
|
||||
- Extrair CSS para arquivo co-localizado
|
||||
- Aplicar padrões de nomenclatura já definidos em rules
|
||||
|
||||
## Ações que Requerem Confirmação
|
||||
|
||||
O agente deve **propor e aguardar aprovação**:
|
||||
|
||||
- Criar novas rules, workflows ou skills
|
||||
- Alterar mais de 5 arquivos em uma única operação
|
||||
- Remover ou renomear artefatos do `.agent/`
|
||||
- Mudar contratos de API (parâmetros, retornos, rotas)
|
||||
- Alterar schemas Zod compartilhados no pacote `*-comuns`
|
||||
- Propor novas dependências ao `package.json`
|
||||
- Mudar configurações de build, deploy ou CI/CD
|
||||
|
||||
## Ações Proibidas
|
||||
|
||||
O agente **nunca** deve:
|
||||
|
||||
- Deletar memória/ADRs sem instrução explícita do operador
|
||||
- Alterar artefatos globais (sufixo `.global`) sem justificativa
|
||||
- Inventar regras de negócio não documentadas
|
||||
- Assumir comportamento de API sem verificar o código-fonte
|
||||
- Usar `any`, `as any` ou `@ts-ignore` para "fazer compilar"
|
||||
- Ignorar erros de `tsc --noEmit` sem investigar a causa
|
||||
|
||||
## Regra de Dúvida
|
||||
|
||||
Quando não souber se uma ação é autônoma ou requer confirmação: **perguntar**.
|
||||
|
||||
O custo de uma pergunta é zero. O custo de uma ação destrutiva é alto.
|
||||
|
||||
## Impacto
|
||||
|
||||
Sem esta regra, o agente pode refatorar 50 arquivos em uma tacada, deletar decisões técnicas, ou criar rules que conflitam com as existentes — tudo sem que o operador tenha oportunidade de revisar.
|
||||
136
global/rules/carta-principios-agente-azteca.md
Normal file
136
global/rules/carta-principios-agente-azteca.md
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
---
|
||||
trigger: always_on
|
||||
type: rule
|
||||
name: carta-principios-agente-azteca
|
||||
description: Princípios morais e operacionais que orientam o comportamento de agentes de IA no ecossistema Azteca
|
||||
version: "1.0"
|
||||
scope: global
|
||||
priority: alta
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Carta de Princípios do Agente de IA da Azteca
|
||||
|
||||
## 🎯 Objetivo
|
||||
|
||||
Estabelecer os princípios fundamentais que orientam o comportamento, decisões e produções de agentes de inteligência artificial utilizados no ecossistema tecnológico da **Azteca**.
|
||||
|
||||
Esta carta serve como referência ética, operacional e estratégica para o funcionamento dos agentes.
|
||||
|
||||
---
|
||||
|
||||
# 1️⃣ Identidade do Agente
|
||||
|
||||
O agente de IA é uma ferramenta digital derivada da evolução do conhecimento humano, projetada para:
|
||||
|
||||
- interpretar informações
|
||||
- gerar textos
|
||||
- produzir código
|
||||
- realizar análises
|
||||
- apoiar decisões
|
||||
|
||||
Seu propósito é **transformar conhecimento em utilidade prática**.
|
||||
|
||||
---
|
||||
|
||||
# 2️⃣ Princípio de Serviço à Humanidade
|
||||
|
||||
O agente deve direcionar sua atuação para contribuir com o desenvolvimento humano, considerando sempre três dimensões fundamentais:
|
||||
|
||||
- sustentabilidade econômica
|
||||
- sustentabilidade ambiental
|
||||
- sustentabilidade social
|
||||
|
||||
Toda produção deve buscar gerar benefícios e evitar impactos negativos à sociedade.
|
||||
|
||||
---
|
||||
|
||||
# 3️⃣ Princípio de Serviço à Organização
|
||||
|
||||
Quando operando no contexto da **Azteca**, o agente deve contribuir para:
|
||||
|
||||
- criação de soluções tecnológicas relevantes
|
||||
- aumento da eficiência operacional
|
||||
- redução de custos e desperdícios
|
||||
- geração de valor para clientes
|
||||
- fortalecimento da reputação da empresa
|
||||
- melhoria contínua dos ambientes de trabalho
|
||||
|
||||
---
|
||||
|
||||
# 4️⃣ Princípio de Apoio ao Operador
|
||||
|
||||
O operador humano é responsável pelas decisões estratégicas.
|
||||
|
||||
O agente deve:
|
||||
|
||||
- interpretar intenções
|
||||
- apoiar análises
|
||||
- produzir códigos e soluções
|
||||
- organizar conhecimento
|
||||
- reduzir complexidade técnica
|
||||
|
||||
O agente existe para **ampliar a capacidade humana de realizar tarefas e tomar decisões.**
|
||||
|
||||
---
|
||||
|
||||
# 5️⃣ Princípio da Clareza e Precisão
|
||||
|
||||
Toda produção do agente deve priorizar:
|
||||
|
||||
- clareza
|
||||
- precisão técnica
|
||||
- coerência lógica
|
||||
- utilidade prática
|
||||
- organização da informação
|
||||
|
||||
Respostas devem ser estruturadas de forma que possam ser reutilizadas.
|
||||
|
||||
---
|
||||
|
||||
# 6️⃣ Princípio da Responsabilidade
|
||||
|
||||
O agente deve evitar produzir conteúdos que possam causar:
|
||||
|
||||
- danos a pessoas
|
||||
- prejuízos a organizações
|
||||
- degradação ambiental
|
||||
- desinformação
|
||||
|
||||
A tecnologia deve ser utilizada como instrumento de construção e melhoria.
|
||||
|
||||
---
|
||||
|
||||
# 7️⃣ Princípio da Evolução Contínua
|
||||
|
||||
O agente deve buscar aprimoramento constante por meio de:
|
||||
|
||||
- aprendizado com interações
|
||||
- consolidação de novos conhecimentos
|
||||
- atualização de práticas e padrões
|
||||
- adaptação a novos contextos tecnológicos
|
||||
|
||||
---
|
||||
|
||||
# 8️⃣ Regra Fundamental
|
||||
|
||||
Sempre que houver dúvida entre diferentes caminhos de resposta, o agente deve priorizar:
|
||||
|
||||
1. utilidade para o operador
|
||||
2. benefício para a organização
|
||||
3. responsabilidade social e ambiental
|
||||
4. clareza e qualidade técnica
|
||||
|
||||
---
|
||||
|
||||
# 📌 Aplicação
|
||||
|
||||
Esta rule deve orientar:
|
||||
|
||||
- agentes programadores
|
||||
- agentes analistas
|
||||
- copilots de desenvolvimento
|
||||
- automações baseadas em IA
|
||||
- sistemas de suporte à decisão
|
||||
|
||||
Ela funciona como **constituição comportamental dos agentes da Azteca**.
|
||||
120
global/rules/fronteiras-monorepo.md
Normal file
120
global/rules/fronteiras-monorepo.md
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
---
|
||||
type: rule
|
||||
name: fronteiras-monorepo
|
||||
description: Define a convenção de pacotes e regras de importação entre módulos do monorepo
|
||||
scope: global
|
||||
trigger: always_on
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Regra: Fronteiras de Pacote no Monorepo
|
||||
|
||||
## Contexto
|
||||
|
||||
Cada módulo SaaS do ecossistema é organizado em até 4 pacotes dentro de um monorepo. O agente **deve** respeitar as fronteiras de importação entre pacotes para evitar acoplamento indevido.
|
||||
|
||||
## Convenção de Pacotes
|
||||
|
||||
Cada módulo segue a estrutura:
|
||||
|
||||
```
|
||||
<modulo>-back ← Servidor: rotas, serviços, filas, CRON
|
||||
<modulo>-front ← Interface: páginas Vue, componentes, composables
|
||||
<modulo>-comuns ← Compartilhado: tipos, schemas Zod, enums, utils puros
|
||||
<modulo>-migracao ← Banco de dados: migrations, seeds, scripts de carga
|
||||
```
|
||||
|
||||
Nem todo módulo terá os 4 pacotes. O mínimo funcional é `back` + `front` + `comuns`.
|
||||
|
||||
## Regras de Importação
|
||||
|
||||
### Permitido ✅
|
||||
|
||||
```
|
||||
<modulo>-front → pode importar de → <modulo>-comuns
|
||||
<modulo>-back → pode importar de → <modulo>-comuns
|
||||
<modulo>-migracao → pode importar de → <modulo>-comuns
|
||||
```
|
||||
|
||||
### Proibido ❌
|
||||
|
||||
```
|
||||
<modulo>-front ✗ nunca importar de → <modulo>-back
|
||||
<modulo>-back ✗ nunca importar de → <modulo>-front
|
||||
<modulo>-migracao ✗ nunca importar de → <modulo>-front
|
||||
<modulo>-front ✗ nunca importar de → <outro-modulo>-back
|
||||
<outro-modulo> ✗ nunca importar de → <modulo>-back (direto)
|
||||
```
|
||||
|
||||
### Comunicação entre módulos
|
||||
|
||||
Módulos diferentes **nunca** importam código um do outro diretamente. Comunicação entre módulos deve ocorrer via:
|
||||
|
||||
- **API HTTP** (chamada de serviço entre backs)
|
||||
- **Fila** (BullMQ, Redis) para processamento assíncrono
|
||||
- **Banco compartilhado** com schemas/tabelas separados por módulo
|
||||
- **Pacote `*-comuns` compartilhado** apenas para tipos e schemas de contrato
|
||||
|
||||
## O que vive em cada pacote
|
||||
|
||||
### `<modulo>-comuns`
|
||||
|
||||
O pacote comuns é a **única fonte de verdade** para tipos e schemas compartilhados:
|
||||
|
||||
```
|
||||
<modulo>-comuns/src/
|
||||
├── tabelas/ ← schemas Zod por entidade (zEntidadeCriar, etc.)
|
||||
├── enums/ ← enums de domínio do módulo
|
||||
├── tipos/ ← tipos derivados dos schemas
|
||||
└── utils/ ← funções puras sem side-effect
|
||||
```
|
||||
|
||||
**Proibido** no comuns:
|
||||
- Componentes Vue ou React
|
||||
- Código com `import` de Node.js (`fs`, `path`, `http`)
|
||||
- Código com `import` de bibliotecas de frontend (`vue`, `vuetify`)
|
||||
- Lógica de negócio que depende de banco ou serviço externo
|
||||
|
||||
### `<modulo>-back`
|
||||
|
||||
```
|
||||
<modulo>-back/src/
|
||||
├── rotas/ ← endpoints Express/Fastify
|
||||
├── servicos/ ← lógica de negócio
|
||||
├── banco/ ← queries (Knex, Prisma, etc.)
|
||||
├── filas/ ← processadores de fila
|
||||
├── cron/ ← tarefas agendadas
|
||||
└── utils/ ← helpers exclusivos do back
|
||||
```
|
||||
|
||||
### `<modulo>-front`
|
||||
|
||||
```
|
||||
<modulo>-front/src/
|
||||
├── paginas/ ← páginas/views por rota
|
||||
├── componentes/ ← componentes reutilizáveis do módulo
|
||||
├── composables/ ← lógica reutilizável (use*.ts)
|
||||
└── utils/ ← helpers exclusivos do front
|
||||
```
|
||||
|
||||
### `<modulo>-migracao`
|
||||
|
||||
```
|
||||
<modulo>-migracao/src/
|
||||
├── migrations/ ← criação/alteração de tabelas
|
||||
├── seeds/ ← dados iniciais
|
||||
└── scripts/ ← scripts de carga/transformação
|
||||
```
|
||||
|
||||
## Impacto
|
||||
|
||||
Sem esta regra:
|
||||
- Front importa serviço de back (quebra em build de produção)
|
||||
- Módulo A acessa tabelas do Módulo B diretamente (acoplamento oculto)
|
||||
- Schemas ficam duplicados entre back e front
|
||||
- Mudança em um módulo quebra outro sem aviso
|
||||
|
||||
## Referências
|
||||
|
||||
- Rule: `.agent/rules/zod-validacao-padrao.global.md` (schemas no `*-comuns`)
|
||||
- Skill: `.agent/skills/mapear-codigo-fonte.global/SKILL.md`
|
||||
66
global/rules/limite-linhas.md
Normal file
66
global/rules/limite-linhas.md
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
---
|
||||
type: rule
|
||||
name: limite-linhas
|
||||
description: Nenhum arquivo de código pode ultrapassar 250 linhas
|
||||
scope: global
|
||||
trigger: file_match
|
||||
globs:
|
||||
- "**/*.ts"
|
||||
- "**/*.tsx"
|
||||
- "**/*.vue"
|
||||
- "**/*.css"
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Regra: Limite de 250 Linhas por Arquivo
|
||||
|
||||
## Regra
|
||||
|
||||
Nenhum arquivo `*.vue`, `*.ts`, `*.tsx` ou `*.css` pode ultrapassar **250 linhas**.
|
||||
|
||||
> Validação automática: `.agent/verificar-linhas.sh`
|
||||
|
||||
## Estratégias de Decomposição
|
||||
|
||||
| Situação | Ação |
|
||||
|---|---|
|
||||
| Template longo | Extrair seções como subcomponentes |
|
||||
| CSS extenso | Mover para `<nome>.css` co-localizado |
|
||||
| `setup()` extenso | Extrair subcomponentes, CSS ou Dispatch Table |
|
||||
| Modal/Dialog embutido | Sempre em componente separado (`*Modal.vue`) |
|
||||
| Handlers e dispatch | Extrair para `handlers.ts` ou `dispatch.ts` |
|
||||
|
||||
## Divisão em Pasta
|
||||
|
||||
Quando um componente precisa de múltiplos sub-arquivos, converter em **pasta homônima** com `index.vue`:
|
||||
|
||||
```
|
||||
# Antes
|
||||
ComponenteGrande.vue ← monolítico (+250 linhas)
|
||||
|
||||
# Depois
|
||||
ComponenteGrande/
|
||||
├── index.vue ← orquestração (≤250 linhas)
|
||||
├── SecaoPrincipal.vue ← bloco de template extraído
|
||||
├── SecaoSecundaria.vue ← outro bloco extraído
|
||||
├── componenteGrande.mapeadores.ts ← lógica de eventos
|
||||
└── ComponenteGrande.css ← estilos co-localizados
|
||||
```
|
||||
|
||||
| Arquivo | Responsabilidade |
|
||||
|---|---|
|
||||
| `index.vue` | Orquestração: importa e compõe. Sem lógica densa. |
|
||||
| `Secao*.vue` | Template isolado. Props + eventos. |
|
||||
| `*.mapeadores.ts` | Funções de ação desacopladas. |
|
||||
| `*.css` | Estilos co-localizados. |
|
||||
|
||||
> Importações externas não mudam: `ComponenteGrande/` resolve para `index.vue`.
|
||||
|
||||
## Impacto
|
||||
|
||||
Sem esta regra, arquivos crescem silenciosamente até se tornarem intocáveis — ninguém quer revisar ou refatorar um componente de 800 linhas.
|
||||
|
||||
## Referências
|
||||
|
||||
- Script: `.agent/verificar-linhas.sh`
|
||||
- Workflow: `.agent/workflows/otimizar-codigos.global.md`
|
||||
120
global/rules/regras-negocio-md.md
Normal file
120
global/rules/regras-negocio-md.md
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
---
|
||||
type: rule
|
||||
name: regras-negocio-md
|
||||
description: Arquivo {modulo}.regras-negocio.md obrigatório para módulos com lógica complexa
|
||||
scope: global
|
||||
trigger: always_on
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Regra: Arquivo `{modulo}.regras-negocio.md` Obrigatório para Módulos com Lógica Complexa
|
||||
|
||||
> **Escopo global** — aplica-se a todos os projetos do ecossistema Azteca.
|
||||
|
||||
## Contexto
|
||||
|
||||
Qualquer arquivo TypeScript que contenha lógica de negócio não-trivial — múltiplas regras de decisão, critérios de bloqueio, estratégias de processamento — deve ter suas regras documentadas em linguagem natural em um arquivo Markdown co-localizado.
|
||||
|
||||
Isso garante que produto, suporte e desenvolvimento possam entender as regras sem precisar ler TypeScript, e que o agente de IA encontre rapidamente os critérios corretos antes de alterar qualquer código.
|
||||
|
||||
## Regra
|
||||
|
||||
**Todo módulo com lógica de negócio não-trivial DEVE ter um arquivo `{modulo}.regras-negocio.md` co-localizado.**
|
||||
|
||||
Considera-se lógica não-trivial qualquer módulo que:
|
||||
- possui 3 ou mais critérios de decisão distintos
|
||||
- realiza eleição/priorização entre registros
|
||||
- aplica diferentes estratégias por tipo de dado
|
||||
- pode resultar em revisão manual (caminho alternativo ao fluxo automático)
|
||||
- é consumido por CRON, worker ou importador automático
|
||||
|
||||
O módulo TypeScript deve conter, na primeira linha do arquivo, a referência:
|
||||
|
||||
```typescript
|
||||
// Regras de negócio: ver {modulo}.regras-negocio.md
|
||||
```
|
||||
|
||||
O arquivo `.md` é a **fonte de verdade**. Os JSDoc do código devem referenciar o `.md`, não duplicá-lo.
|
||||
|
||||
## Estrutura Obrigatória do Arquivo
|
||||
|
||||
```markdown
|
||||
# Regras de Negócio — [Nome do Módulo]
|
||||
|
||||
Módulo: `_arquivo.ts`
|
||||
Localização: `caminho/relativo/ao/arquivo`
|
||||
|
||||
---
|
||||
|
||||
## Contexto
|
||||
Por que este módulo existe, qual problema resolve.
|
||||
|
||||
## Critérios de Entrada / Identificação
|
||||
O que aciona o módulo, quais dados recebe, filtros aplicados.
|
||||
|
||||
## Regras de Processamento
|
||||
As regras numeradas em ordem de avaliação.
|
||||
|
||||
## Casos de Revisão Manual (quando aplicável)
|
||||
Quando o processamento automático não pode prosseguir.
|
||||
|
||||
## Estratégia de Fusão / Resultado (quando aplicável)
|
||||
O que o módulo produz, como campos são combinados.
|
||||
|
||||
## Dependências Externas
|
||||
Tabelas, filas, serviços externos tocados pelo módulo.
|
||||
```
|
||||
|
||||
## Exemplos
|
||||
|
||||
✅ **Correto** — referência no topo do módulo, regras no `.md`:
|
||||
```typescript
|
||||
// Regras de negócio: ver juntar_execucoes.regras-negocio.md
|
||||
|
||||
import { ... } from "..."
|
||||
|
||||
export const compilarJuntarExecucoes = async (...) => {
|
||||
// implementação conforme regras-negocio.md
|
||||
}
|
||||
```
|
||||
|
||||
❌ **Errado** — regras embutidas no código como comentário de bloco:
|
||||
```typescript
|
||||
/**
|
||||
* Regras de negócio:
|
||||
* [x] Pode ter apenas uma execução por data de vencimento.
|
||||
* [x] Se tiver apenas uma execução consolidada → ela é a principal.
|
||||
* ...
|
||||
*/
|
||||
```
|
||||
|
||||
❌ **Errado** — JSDoc duplicando as regras em vez de referenciar o `.md`:
|
||||
```typescript
|
||||
/**
|
||||
* Retorna false quando:
|
||||
* - vencimentos divergentes
|
||||
* - executada com datas distintas
|
||||
* - vencimento_prorrogado distintos
|
||||
* ...
|
||||
*/
|
||||
```
|
||||
|
||||
## Impacto
|
||||
|
||||
Sem este padrão:
|
||||
- Regras de negócio ficam implícitas no código ou em JSDoc que envelhece sem controle
|
||||
- O agente de IA precisa inferir regras do código ao invés de lê-las diretamente
|
||||
- Produto e suporte não conseguem validar o comportamento sem ajuda técnica
|
||||
- Mudanças de regra geram JSDoc desatualizado espalhado pelo código
|
||||
|
||||
## Aplicação
|
||||
|
||||
- Módulos de CRON com lógica de auditoria/fusão
|
||||
- Importadores automáticos (ex: importação de licenças via IA)
|
||||
- Workers de processamento em lote
|
||||
- Qualquer utilitário com lógica de decisão multi-critério
|
||||
|
||||
## Referências
|
||||
|
||||
- Skill: `.agent/skills/documentar-regras-negocio.global/SKILL.md`
|
||||
- Workflow: `.agent/workflows/documentar-regras-negocio.global.md`
|
||||
77
global/rules/typescript-sem-any.md
Normal file
77
global/rules/typescript-sem-any.md
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
---
|
||||
type: rule
|
||||
name: typescript-sem-any
|
||||
trigger: always_on
|
||||
description: Proíbe uso de any, casts inseguros e padroniza uso de enums em código TypeScript
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
globs:
|
||||
- "**/*.ts"
|
||||
- "**/*.tsx"
|
||||
- "**/*.vue"
|
||||
alwaysApply: true
|
||||
---
|
||||
|
||||
Regras obrigatórias para TypeScript neste projeto:
|
||||
|
||||
- Nunca usar `any`.
|
||||
- Nunca usar `as any`.
|
||||
- Nunca contornar erro de tipagem com cast forçado.
|
||||
- Quando o tipo não for conhecido, usar `unknown`.
|
||||
- Antes de acessar valores `unknown`, fazer narrowing com:
|
||||
- `typeof`
|
||||
- `in`
|
||||
- `Array.isArray`
|
||||
- type guards
|
||||
- schemas de validação como Zod
|
||||
- Preferir:
|
||||
- generics
|
||||
- union types
|
||||
- `Record<string, unknown>`
|
||||
- `Partial<T>`
|
||||
- `Pick<T, K>`
|
||||
- `PropType<T>` em Vue
|
||||
- tipos derivados de funções existentes
|
||||
- Se faltar tipo, o agente deve:
|
||||
1. procurar tipos já existentes no projeto;
|
||||
2. criar um tipo/interface local explícita;
|
||||
3. inferir a partir do contexto sempre que possível;
|
||||
4. deixar um `TODO de tipagem` explícito, mas sem usar `any`.
|
||||
|
||||
Regras obrigatórias para uso de enums:
|
||||
|
||||
- Quando um valor estiver associado a um `enum`, é obrigatório utilizar o enum, nunca strings literais.
|
||||
- O acesso deve seguir o padrão: `<NomeEnum>.VALOR`.
|
||||
|
||||
Também é proibido, quando existir `enum` correspondente:
|
||||
|
||||
- utilizar strings literais no lugar do enum (ex: `"ativo"`, `"inativo"`, `"automatica"`, `"criar"`);
|
||||
- utilizar cast para forçar compatibilidade com enum (ex: `"ativo" as StatusConta`).
|
||||
|
||||
Proibido gerar código que apenas "faça compilar" usando:
|
||||
|
||||
- `as any`
|
||||
- `: any`
|
||||
- `[] as any`
|
||||
- `{ } as any`
|
||||
- dupla coerção como `as unknown as any`
|
||||
|
||||
Em casos excepcionais, preferir:
|
||||
|
||||
- `as unknown as TipoEspecifico` somente se houver justificativa clara e comentário técnico.
|
||||
|
||||
Diretriz para o agente:
|
||||
|
||||
Se encontrar uma string que represente um valor de domínio do sistema, o agente deve:
|
||||
|
||||
1. procurar se já existe um `enum` correspondente no projeto;
|
||||
2. usar o `enum` existente;
|
||||
3. se não existir, propor a criação de um `enum` explícito, em vez de manter strings soltas.
|
||||
|
||||
---
|
||||
|
||||
## Referências
|
||||
|
||||
- Skill: `.agent/skills/diagnosticar-erros-build.global/SKILL.md` (quando erros de tipagem causam falhas de build em cascata)
|
||||
- Workflow: `.agent/workflows/otimizar-codigos.global.md` (padrão de documentação para casts temporários)
|
||||
|
||||
315
global/rules/zod-validacao-padrao.md
Normal file
315
global/rules/zod-validacao-padrao.md
Normal file
|
|
@ -0,0 +1,315 @@
|
|||
---
|
||||
type: rule
|
||||
name: zod-validacao-padrao
|
||||
description: Estabelece Zod como biblioteca obrigatória de validação em todo o ecossistema Azteca
|
||||
version: "1.0"
|
||||
scope: global
|
||||
priority: alta
|
||||
trigger: always_on
|
||||
globs:
|
||||
- "**/*.ts"
|
||||
- "**/*.tsx"
|
||||
- "**/*.vue"
|
||||
alwaysApply: true
|
||||
updatedAt: "2026-06-01"
|
||||
references:
|
||||
- .agent/rules/typescript-sem-any.global.md
|
||||
- .agent/skills/criar-schema-zod.global/SKILL.md
|
||||
---
|
||||
|
||||
# Regra: Zod como Validador Padrão
|
||||
|
||||
## Contexto
|
||||
|
||||
Todo projeto do ecossistema Azteca que receba dados externos — API, formulário, webhook, importação, fila, variáveis de ambiente — **deve** validar esses dados com [Zod](https://zod.dev).
|
||||
|
||||
Zod é a única biblioteca de validação autorizada porque:
|
||||
|
||||
- Inferência nativa de tipos TypeScript (`z.infer<>`) — elimina duplicação entre schema e tipo
|
||||
- Bundle pequeno (~13KB gzipped) — viável no frontend
|
||||
- Compartilhável entre back e front via pacotes `*-comuns`
|
||||
- Ecossistema maduro: `zod-to-json-schema`, `@anatine/zod-nestjs`, integração com `tRPC`
|
||||
|
||||
---
|
||||
|
||||
## Regra
|
||||
|
||||
### 1. Toda entrada externa deve ser validada com Zod
|
||||
|
||||
Entradas externas incluem:
|
||||
|
||||
- **Corpo de requisição** (API REST, webhook, GraphQL)
|
||||
- **Query params e path params**
|
||||
- **Formulários de frontend**
|
||||
- **Dados de fila** (BullMQ, Redis, etc.)
|
||||
- **Arquivos importados** (CSV, JSON, Excel)
|
||||
- **Variáveis de ambiente**
|
||||
- **Respostas de APIs externas** (quando a resposta não é confiável)
|
||||
|
||||
### 2. Schemas devem residir no pacote `*-comuns`
|
||||
|
||||
Para que front e back compartilhem os mesmos schemas, eles devem residir no pacote `<modulo>-comuns`:
|
||||
|
||||
```
|
||||
<modulo>-comuns/src/
|
||||
├── tabelas/
|
||||
│ ├── usuarios/
|
||||
│ │ ├── zUsuarioCriar.ts
|
||||
│ │ ├── zUsuarioEditar.ts
|
||||
│ │ └── index.ts
|
||||
│ ├── empresas/
|
||||
│ │ ├── zEmpresaCriar.ts
|
||||
│ │ └── index.ts
|
||||
│ └── index.ts
|
||||
```
|
||||
|
||||
### 3. Tipos devem ser derivados dos schemas (nunca o inverso)
|
||||
|
||||
```typescript
|
||||
// ✅ CORRETO — tipo derivado do schema
|
||||
export const zUsuarioCriar = z.object({
|
||||
nome: z.string().min(1),
|
||||
email: z.string().email(),
|
||||
ativo: z.boolean().default(true),
|
||||
})
|
||||
export type tipoUsuarioCriar = z.infer<typeof zUsuarioCriar>
|
||||
|
||||
// ❌ ERRADO — tipo manual separado do schema
|
||||
interface UsuarioCriar {
|
||||
nome: string
|
||||
email: string
|
||||
ativo?: boolean
|
||||
}
|
||||
const zUsuarioCriar = z.object({ ... }) // duplicação!
|
||||
```
|
||||
|
||||
### 4. Nomenclatura obrigatória de schemas
|
||||
|
||||
| Padrão | Uso | Exemplo |
|
||||
|--------|-----|---------|
|
||||
| `z{Entidade}Criar` | Criação de registro | `zUsuarioCriar` |
|
||||
| `z{Entidade}Editar` | Edição de registro | `zUsuarioEditar` |
|
||||
| `z{Entidade}Filtro` | Filtros de listagem | `zUsuarioFiltro` |
|
||||
| `z{Entidade}Resposta` | Resposta de API | `zUsuarioResposta` |
|
||||
| `z{Entidade}Params` | Parâmetros de rota | `zUsuarioParams` |
|
||||
| `z{Modulo}Config` | Configuração do módulo | `zGeeConfig` |
|
||||
| `z{Modulo}Ambiente` | Variáveis de ambiente | `zBackAmbiente` |
|
||||
|
||||
Prefixo `z` minúsculo + nome em `PascalCase`.
|
||||
|
||||
### 5. Usar `safeParse` em vez de `parse` para erros controlados
|
||||
|
||||
```typescript
|
||||
// ✅ CORRETO — erro controlado
|
||||
const resultado = zUsuarioCriar.safeParse(dados)
|
||||
if (!resultado.success) {
|
||||
return respostaComuns.erro(resultado.error.issues[0].message)
|
||||
}
|
||||
const usuario = resultado.data // tipado automaticamente
|
||||
|
||||
// ❌ ERRADO — throw não controlado
|
||||
const usuario = zUsuarioCriar.parse(dados) // lança ZodError
|
||||
```
|
||||
|
||||
A exceção é em contextos onde o throw é desejável (middleware global, início de pipeline).
|
||||
|
||||
### 6. Nunca usar validação manual quando Zod resolve
|
||||
|
||||
```typescript
|
||||
// ❌ ERRADO — validação manual
|
||||
if (!dados.nome || typeof dados.nome !== "string") {
|
||||
return erro("Nome é obrigatório")
|
||||
}
|
||||
if (!dados.email || !dados.email.includes("@")) {
|
||||
return erro("Email inválido")
|
||||
}
|
||||
|
||||
// ✅ CORRETO — Zod faz tudo
|
||||
const resultado = zUsuarioCriar.safeParse(dados)
|
||||
if (!resultado.success) {
|
||||
return erro(resultado.error.issues[0].message)
|
||||
}
|
||||
```
|
||||
|
||||
### 7. Transformações e defaults pertencem ao schema
|
||||
|
||||
```typescript
|
||||
// ✅ CORRETO — transformação no schema
|
||||
export const zProdutoCriar = z.object({
|
||||
nome: z.string().trim().min(1),
|
||||
preco: z.coerce.number().positive(),
|
||||
ativo: z.boolean().default(true),
|
||||
codigo: z.string().toUpperCase().optional(),
|
||||
tags: z.array(z.string()).default([]),
|
||||
})
|
||||
|
||||
// ❌ ERRADO — transformação manual após validação
|
||||
const produto = zProdutoCriar.parse(dados)
|
||||
produto.nome = produto.nome.trim()
|
||||
produto.codigo = produto.codigo?.toUpperCase()
|
||||
```
|
||||
|
||||
### 8. Composição de schemas em vez de duplicação
|
||||
|
||||
```typescript
|
||||
// ✅ CORRETO — composição
|
||||
const zEndereco = z.object({
|
||||
rua: z.string(),
|
||||
cidade: z.string(),
|
||||
uf: z.string().length(2),
|
||||
})
|
||||
|
||||
const zEmpresaCriar = z.object({
|
||||
nome: z.string(),
|
||||
endereco: zEndereco,
|
||||
})
|
||||
|
||||
const zEmpresaEditar = zEmpresaCriar.partial() // todos opcionais
|
||||
|
||||
const zEmpresaResposta = zEmpresaCriar.extend({
|
||||
codigo: z.string().uuid(),
|
||||
criadoEm: z.string().datetime(),
|
||||
})
|
||||
|
||||
// ❌ ERRADO — copiar campos entre schemas
|
||||
const zEmpresaEditar = z.object({
|
||||
nome: z.string().optional(), // duplicou!
|
||||
endereco: z.object({ // duplicou!
|
||||
rua: z.string().optional(),
|
||||
cidade: z.string().optional(),
|
||||
}),
|
||||
})
|
||||
```
|
||||
|
||||
### 9. Enums Zod para valores de domínio
|
||||
|
||||
```typescript
|
||||
// ✅ CORRETO — enum Zod quando os valores vêm de dados externos
|
||||
export const zStatusLicenca = z.enum(["ativa", "vencida", "suspensa", "cancelada"])
|
||||
export type tipoStatusLicenca = z.infer<typeof zStatusLicenca>
|
||||
|
||||
// Usar em outros schemas
|
||||
const zLicencaCriar = z.object({
|
||||
status: zStatusLicenca,
|
||||
// ...
|
||||
})
|
||||
|
||||
// ✅ TAMBÉM CORRETO — TypeScript enum quando já existe no projeto
|
||||
// e o schema referencia o enum
|
||||
import { StatusLicenca } from "./enums"
|
||||
const zLicencaCriar = z.object({
|
||||
status: z.nativeEnum(StatusLicenca),
|
||||
})
|
||||
```
|
||||
|
||||
### 10. Bibliotecas proibidas para validação
|
||||
|
||||
| ❌ Proibido | Motivo |
|
||||
|-------------|--------|
|
||||
| `joi` | Não infere tipos TS, bundle pesado |
|
||||
| `yup` | Inferência fraca, API menos ergonômica |
|
||||
| `class-validator` | Decorators, não compartilhável com frontend |
|
||||
| `io-ts` | Verboso, curva de aprendizado alta |
|
||||
| `ajv` (direto) | JSON Schema — usar `zod-to-json-schema` se precisar de JSON Schema |
|
||||
| Validação manual com `if/typeof` | Quando Zod resolve o mesmo caso |
|
||||
|
||||
---
|
||||
|
||||
## Exemplos
|
||||
|
||||
### API backend (Express)
|
||||
|
||||
```typescript
|
||||
// ✅ Correto
|
||||
import { zUsuarioCriar } from "projeto-comuns/tabelas/usuarios"
|
||||
|
||||
app.post("/usuarios", async (req, res) => {
|
||||
const resultado = zUsuarioCriar.safeParse(req.body)
|
||||
if (!resultado.success) {
|
||||
return res.status(400).json({ erro: resultado.error.issues })
|
||||
}
|
||||
const usuario = await criarUsuario(resultado.data)
|
||||
return res.json(usuario)
|
||||
})
|
||||
```
|
||||
|
||||
### Webhook com fila
|
||||
|
||||
```typescript
|
||||
// ✅ Correto — valida antes de enfileirar
|
||||
const zPayloadWebhook = z.object({
|
||||
tabela: z.enum(["empreendedores", "empreendimentos", "usuarios"]),
|
||||
dados: z.array(z.unknown()).min(1),
|
||||
})
|
||||
|
||||
app.post("/webhook/:tabela", async (req, res) => {
|
||||
const resultado = zPayloadWebhook.safeParse({
|
||||
tabela: req.params.tabela,
|
||||
dados: req.body,
|
||||
})
|
||||
if (!resultado.success) {
|
||||
return res.status(400).json({ erro: "Payload inválido" })
|
||||
}
|
||||
await fila.add("sync", resultado.data)
|
||||
return res.json({ ok: true })
|
||||
})
|
||||
```
|
||||
|
||||
### Variáveis de ambiente
|
||||
|
||||
```typescript
|
||||
// ✅ Correto — validar no boot da aplicação
|
||||
const zAmbiente = z.object({
|
||||
DATABASE_URL: z.string().url(),
|
||||
REDIS_HOST: z.string().default("localhost"),
|
||||
REDIS_PORT: z.coerce.number().default(6379),
|
||||
BASE_URL: z.string().url(),
|
||||
SESSAO_BACK: z.string().uuid(),
|
||||
NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
|
||||
})
|
||||
|
||||
export const ambiente = () => zAmbiente.parse(process.env)
|
||||
```
|
||||
|
||||
### Frontend (formulário Vue)
|
||||
|
||||
```typescript
|
||||
// ✅ Correto — schema compartilhado validando antes de enviar
|
||||
import { zUsuarioCriar } from "projeto-comuns/tabelas/usuarios"
|
||||
|
||||
const salvar = async () => {
|
||||
const resultado = zUsuarioCriar.safeParse(formulario.value)
|
||||
if (!resultado.success) {
|
||||
erros.value = resultado.error.flatten().fieldErrors
|
||||
return
|
||||
}
|
||||
await api.post("/usuarios", resultado.data)
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Impacto
|
||||
|
||||
Sem esta regra:
|
||||
|
||||
- Cada desenvolvedor escolhe uma estratégia diferente de validação (if/typeof, joi, yup, etc.)
|
||||
- Tipos e schemas ficam dessincronizados — mudança no schema não reflete no tipo e vice-versa
|
||||
- Validações manuais são incompletas e inconsistentes entre endpoints
|
||||
- Código de validação é duplicado entre front e back
|
||||
- Dados inválidos passam despercebidos e corrompem a base
|
||||
|
||||
Com esta regra:
|
||||
|
||||
- Uma única fonte de verdade: o schema Zod
|
||||
- Tipos TypeScript sempre sincronizados via `z.infer<>`
|
||||
- Validação consistente em todos os pontos de entrada
|
||||
- Reutilização entre front, back e workers via pacote `*-comuns`
|
||||
- Erros de validação estruturados e internacionalizáveis
|
||||
|
||||
---
|
||||
|
||||
## Referências
|
||||
|
||||
- Rule: `.agent/rules/typescript-sem-any.global.md` (narrowing com Zod mencionado como alternativa)
|
||||
- Skill: `.agent/skills/criar-schema-zod.global/SKILL.md` (guia prático para criar schemas)
|
||||
184
global/skills/criar-schema-zod/SKILL.md
Normal file
184
global/skills/criar-schema-zod/SKILL.md
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
---
|
||||
name: criar-schema-zod
|
||||
scope: global
|
||||
description: >
|
||||
Guia operacional para criar, organizar e manter schemas de validação Zod em projetos TypeScript.
|
||||
---
|
||||
|
||||
# Skill: Criar Schema Zod
|
||||
|
||||
Use esta skill ao adicionar validação de dados em qualquer ponto de entrada do sistema — API, formulário, webhook, importação, fila ou variáveis de ambiente.
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Identificar a Entrada Externa
|
||||
|
||||
Determinar qual dado externo precisa de validação:
|
||||
|
||||
| Tipo de entrada | Onde validar |
|
||||
|---|---|
|
||||
| Corpo de requisição (POST/PUT) | Handler da rota, antes de qualquer lógica |
|
||||
| Query/path params | Handler da rota |
|
||||
| Formulário frontend | Antes de chamar a API |
|
||||
| Dados de fila (BullMQ) | No processador da fila |
|
||||
| Arquivo importado (CSV/JSON) | No parser, linha a linha |
|
||||
| Variáveis de ambiente | No boot da aplicação |
|
||||
| Resposta de API externa | Após receber a resposta |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Localizar ou Criar o Schema no Pacote Comuns
|
||||
|
||||
Schemas compartilhados vivem no pacote `*-comuns`:
|
||||
|
||||
```
|
||||
projeto-comuns/src/tabelas/
|
||||
├── usuarios/
|
||||
│ ├── zUsuarioCriar.ts
|
||||
│ ├── zUsuarioEditar.ts
|
||||
│ └── index.ts
|
||||
└── index.ts
|
||||
```
|
||||
|
||||
### 2.1. Verificar se já existe
|
||||
|
||||
```bash
|
||||
rg "z{NomeDaEntidade}" --include='*.ts' -l
|
||||
```
|
||||
|
||||
Se já existir → reutilizar ou compor a partir dele (`.extend()`, `.pick()`, `.partial()`).
|
||||
|
||||
### 2.2. Criar o schema
|
||||
|
||||
```typescript
|
||||
import { z } from "zod"
|
||||
|
||||
export const zUsuarioCriar = z.object({
|
||||
nome: z.string().trim().min(1, "Nome é obrigatório"),
|
||||
email: z.string().email("E-mail inválido"),
|
||||
ativo: z.boolean().default(true),
|
||||
})
|
||||
```
|
||||
|
||||
### 2.3. Nomenclatura obrigatória
|
||||
|
||||
| Padrão | Uso |
|
||||
|---|---|
|
||||
| `z{Entidade}Criar` | Criação |
|
||||
| `z{Entidade}Editar` | Edição (geralmente `.partial()`) |
|
||||
| `z{Entidade}Filtro` | Filtros de listagem |
|
||||
| `z{Entidade}Resposta` | Resposta de API |
|
||||
| `z{Entidade}Params` | Parâmetros de rota |
|
||||
| `z{Modulo}Config` | Configuração |
|
||||
| `z{Modulo}Ambiente` | Variáveis de ambiente |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Derivar o Tipo com `z.infer<>`
|
||||
|
||||
```typescript
|
||||
export type tipoUsuarioCriar = z.infer<typeof zUsuarioCriar>
|
||||
```
|
||||
|
||||
**Nunca** criar um `interface` ou `type` manual separado do schema. O tipo **sempre** deriva do schema.
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Implementar `safeParse` no Ponto de Entrada
|
||||
|
||||
### Backend (Express)
|
||||
|
||||
```typescript
|
||||
import { zUsuarioCriar } from "projeto-comuns/tabelas/usuarios"
|
||||
|
||||
app.post("/usuarios", async (req, res) => {
|
||||
const resultado = zUsuarioCriar.safeParse(req.body)
|
||||
if (!resultado.success) {
|
||||
return res.status(400).json({ erro: resultado.error.issues[0].message })
|
||||
}
|
||||
const usuario = await criarUsuario(resultado.data)
|
||||
return res.json(usuario)
|
||||
})
|
||||
```
|
||||
|
||||
### Frontend (Vue)
|
||||
|
||||
```typescript
|
||||
import { zUsuarioCriar } from "projeto-comuns/tabelas/usuarios"
|
||||
|
||||
const salvar = async () => {
|
||||
const resultado = zUsuarioCriar.safeParse(formulario.value)
|
||||
if (!resultado.success) {
|
||||
erros.value = resultado.error.flatten().fieldErrors
|
||||
return
|
||||
}
|
||||
await api.post("/usuarios", resultado.data)
|
||||
}
|
||||
```
|
||||
|
||||
### Variáveis de ambiente
|
||||
|
||||
```typescript
|
||||
const zAmbiente = z.object({
|
||||
DATABASE_URL: z.string().url(),
|
||||
REDIS_HOST: z.string().default("localhost"),
|
||||
NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
|
||||
})
|
||||
|
||||
// Aqui o throw é desejável — a app não deve subir com env inválido
|
||||
export const ambiente = () => zAmbiente.parse(process.env)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 5 — Compor Schemas Derivados
|
||||
|
||||
Quando precisar de variações do mesmo schema, **compor** em vez de duplicar:
|
||||
|
||||
```typescript
|
||||
// Schema base
|
||||
const zProduto = z.object({
|
||||
nome: z.string().trim().min(1),
|
||||
preco: z.coerce.number().positive(),
|
||||
categoria: z.string(),
|
||||
})
|
||||
|
||||
// Edição: todos os campos opcionais
|
||||
const zProdutoEditar = zProduto.partial()
|
||||
|
||||
// Resposta: base + campos gerados
|
||||
const zProdutoResposta = zProduto.extend({
|
||||
codigo: z.string().uuid(),
|
||||
criadoEm: z.string().datetime(),
|
||||
})
|
||||
|
||||
// Filtro: subset de campos opcionais
|
||||
const zProdutoFiltro = zProduto.pick({ categoria: true }).partial()
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 6 — Validar Tipagem
|
||||
|
||||
```bash
|
||||
npx tsc --noEmit
|
||||
```
|
||||
|
||||
Zero erros = concluído.
|
||||
|
||||
---
|
||||
|
||||
## Checklist Final
|
||||
|
||||
- [ ] O schema está no pacote `*-comuns` (quando compartilhado entre front/back)?
|
||||
- [ ] O tipo é derivado do schema com `z.infer<>`?
|
||||
- [ ] A validação usa `safeParse` (exceto em boot/middleware)?
|
||||
- [ ] A nomenclatura segue o padrão `z{Entidade}{Acao}`?
|
||||
- [ ] Transformações (trim, coerce, default) estão no schema, não no handler?
|
||||
- [ ] Schemas derivados usam composição (.partial, .extend, .pick), não duplicação?
|
||||
- [ ] `tsc --noEmit` passa sem erros?
|
||||
|
||||
## Referências
|
||||
|
||||
- Rule: `.agent/rules/zod-validacao-padrao.global.md`
|
||||
- Rule: `.agent/rules/typescript-sem-any.global.md`
|
||||
186
global/skills/diagnosticar-erros-build/SKILL.md
Normal file
186
global/skills/diagnosticar-erros-build/SKILL.md
Normal file
|
|
@ -0,0 +1,186 @@
|
|||
---
|
||||
name: diagnosticar-erros-build
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
description: >
|
||||
Guia operacional para diagnosticar e resolver erros de build em cascata em monorepos TypeScript.
|
||||
---
|
||||
|
||||
# Skill: Diagnosticar Erros de Build em Monorepo TypeScript
|
||||
|
||||
Use esta skill quando o build de um monorepo TypeScript falha — especialmente quando erros aparecem em pacotes que não foram diretamente modificados (erros em cascata).
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Capturar o Erro Completo
|
||||
|
||||
Executar o build com output completo e sem truncamento:
|
||||
|
||||
```bash
|
||||
# pnpm (monorepo completo)
|
||||
pnpm build 2>&1 | head -200
|
||||
|
||||
# Pacote específico
|
||||
pnpm --filter <pacote> build 2>&1
|
||||
|
||||
# tsc direto (se disponível)
|
||||
npx tsc --noEmit --pretty 2>&1 | head -100
|
||||
```
|
||||
|
||||
Identificar:
|
||||
|
||||
- **Qual pacote falhou primeiro** (nem sempre é o que aparece no topo)
|
||||
- **Código do erro** (`TS2304`, `TS2345`, `TS7006`, etc.)
|
||||
- **Arquivo e linha** do erro original
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Classificar o Tipo de Erro
|
||||
|
||||
### Erros de dependência entre pacotes (cascata)
|
||||
|
||||
| Sintoma | Causa provável | Solução |
|
||||
|---------|---------------|---------|
|
||||
| `Cannot find module '@org/xxx'` | Pacote não foi buildado antes | Buildar na ordem correta ou usar `references` |
|
||||
| `Module has no exported member 'X'` | Tipo renomeado/removido no pacote origem | Atualizar import no consumidor |
|
||||
| Tipos `any` infiltrados | Pacote exporta sem `.d.ts` | Verificar `declaration: true` no tsconfig |
|
||||
| `The inferred type cannot be named` | Dependência circular de tipos | Extrair tipo para pacote compartilhado |
|
||||
|
||||
### Erros de configuração
|
||||
|
||||
| Sintoma | Causa provável | Solução |
|
||||
|---------|---------------|---------|
|
||||
| `Cannot use import statement` | `module` errado no tsconfig | Alinhar `module`/`moduleResolution` |
|
||||
| `Relative import paths need extensions` | Node16/NodeNext resolution | Adicionar `.js` nos imports ou mudar para `bundler` |
|
||||
| `rootDir is expected to contain all source files` | Arquivo fora do `rootDir` | Ajustar `rootDir` ou mover arquivo |
|
||||
| `Referenced project must have setting composite` | Project references sem `composite` | Adicionar `composite: true` no tsconfig referenciado |
|
||||
|
||||
### Erros de tipagem
|
||||
|
||||
| Sintoma | Causa provável | Solução |
|
||||
|---------|---------------|---------|
|
||||
| `TS2304: Cannot find name` | Tipo global não declarado | Criar `d.ts` ou importar explicitamente |
|
||||
| `TS2345: Argument not assignable` | Tipos incompatíveis entre versões | Alinhar versão da dependência |
|
||||
| `TS7006: Parameter implicitly has 'any'` | `noImplicitAny` ativado | Tipar o parâmetro explicitamente |
|
||||
| `TS18046: is of type 'unknown'` | Narrowing ausente | Fazer type guard antes de usar |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Identificar a Raiz do Problema
|
||||
|
||||
O erro que aparece **primeiro** nem sempre é a raiz. Seguir esta estratégia:
|
||||
|
||||
### 3.1. Verificar ordem de build
|
||||
|
||||
```bash
|
||||
# Listar dependências internas para entender ordem correta
|
||||
rg '"workspace:' --include='package.json' -l | sort
|
||||
|
||||
# Se usar turbo, verificar o pipeline
|
||||
cat turbo.json | jq '.pipeline.build'
|
||||
```
|
||||
|
||||
### 3.2. Rebuild isolado do pacote raiz
|
||||
|
||||
```bash
|
||||
# Buildar APENAS o pacote mais baixo na hierarquia que apresenta erro
|
||||
pnpm --filter <pacote-raiz> build
|
||||
|
||||
# Se esse buildar com sucesso, subir na hierarquia
|
||||
pnpm --filter <pacote-consumidor> build
|
||||
```
|
||||
|
||||
### 3.3. Verificar checagem de tipos isolada
|
||||
|
||||
```bash
|
||||
# Verificar se a tipagem está correta sem produzir output
|
||||
npx tsc --noEmit -p <caminho>/tsconfig.json
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Resolver Erros em Cascata
|
||||
|
||||
### Estratégia: de baixo para cima
|
||||
|
||||
1. Identificar o pacote **mais fundamental** (aquele que não depende de outros internos)
|
||||
2. Resolver TODOS os erros nesse pacote
|
||||
3. Rebuildar
|
||||
4. Subir para o próximo pacote na cadeia de dependência
|
||||
5. Repetir até o topo
|
||||
|
||||
### Armadilhas comuns
|
||||
|
||||
```typescript
|
||||
// ❌ ERRADO: "resolver" com any (viola typescript-sem-any)
|
||||
const dados = resultado as any
|
||||
|
||||
// ✅ CORRETO: tipar adequadamente
|
||||
const dados: ResultadoEsperado = resultado
|
||||
|
||||
// ❌ ERRADO: ignorar erro com @ts-ignore
|
||||
// @ts-ignore
|
||||
import { funcao } from '@org/pacote'
|
||||
|
||||
// ✅ CORRETO: investigar por que o import falha
|
||||
// O pacote '@org/pacote' foi buildado? O export existe?
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 5 — Verificar Alinhamento de Configuração
|
||||
|
||||
Quando erros persistem entre pacotes, verificar alinhamento de tsconfig:
|
||||
|
||||
```bash
|
||||
# Comparar configurações críticas entre pacotes
|
||||
for f in $(fd tsconfig.json --max-depth 2 --type f); do
|
||||
echo "=== $f ==="
|
||||
jq '{target, module, moduleResolution, strict, composite, declaration}' "$f" 2>/dev/null
|
||||
done
|
||||
```
|
||||
|
||||
Campos que **devem** ser consistentes entre pacotes do mesmo monorepo:
|
||||
|
||||
| Campo | Recomendação |
|
||||
|-------|-------------|
|
||||
| `target` | Mesmo alvo para todos (ex: `ES2022`) |
|
||||
| `module` | Consistente (ex: `ESNext` ou `Node16`) |
|
||||
| `moduleResolution` | Consistente (ex: `bundler` ou `node16`) |
|
||||
| `strict` | `true` em todos |
|
||||
| `declaration` | `true` em libs, opcional em apps |
|
||||
| `composite` | `true` em libs referenciadas |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 6 — Limpar e Rebuildar
|
||||
|
||||
Quando a investigação não revela causa óbvia:
|
||||
|
||||
```bash
|
||||
# Limpar artefatos de build de todos os pacotes
|
||||
fd -t d 'dist|build|.tsbuildinfo' --exclude node_modules | xargs rm -rf
|
||||
|
||||
# Limpar node_modules (último recurso)
|
||||
fd -t d node_modules --max-depth 2 | xargs rm -rf
|
||||
|
||||
# Reinstalar e rebuildar do zero
|
||||
pnpm install && pnpm build
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Checklist Final
|
||||
|
||||
- [ ] O pacote raiz do erro em cascata foi identificado?
|
||||
- [ ] O erro original (não o efeito cascata) foi localizado?
|
||||
- [ ] A solução não usa `any`, `as any` ou `@ts-ignore`?
|
||||
- [ ] Todos os pacotes na cadeia foram rebuildados após a correção?
|
||||
- [ ] As configurações de tsconfig estão alinhadas entre pacotes?
|
||||
- [ ] O build completo passa sem erros?
|
||||
|
||||
## Referências
|
||||
|
||||
- Rules: `.agent/rules/typescript-sem-any.global.md`
|
||||
- Workflow: `.agent/workflows/otimizar-codigos.global.md`
|
||||
- Skill: `.agent/skills/mapear-codigo-fonte.global/SKILL.md`
|
||||
161
global/skills/documentar-decisao-tecnica/SKILL.md
Normal file
161
global/skills/documentar-decisao-tecnica/SKILL.md
Normal file
|
|
@ -0,0 +1,161 @@
|
|||
---
|
||||
name: documentar-decisao-tecnica
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
description: >
|
||||
Guia operacional para registrar decisões técnicas e arquiteturais como ADRs (Architecture Decision Records).
|
||||
---
|
||||
|
||||
# Skill: Documentar Decisão Técnica (ADR)
|
||||
|
||||
Use esta skill sempre que uma decisão técnica significativa for tomada — escolha de biblioteca, mudança de arquitetura, padrão de código, migração, ou qualquer decisão que afete múltiplos pacotes ou desenvolvedores.
|
||||
|
||||
O objetivo é garantir que **nenhuma decisão fique apenas na cabeça** ou perdida em conversas.
|
||||
|
||||
---
|
||||
|
||||
## Quando usar
|
||||
|
||||
- Nova dependência adicionada ao monorepo
|
||||
- Mudança de padrão arquitetural (ex: de REST para GraphQL)
|
||||
- Escolha de ferramenta ou lib entre alternativas
|
||||
- Decisão de breaking change
|
||||
- Migração de tecnologia
|
||||
- Mudança de estratégia de deploy ou CI/CD
|
||||
- Qualquer decisão que alguém pode questionar daqui 3 meses
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Criar o Diretório de ADRs (se não existir)
|
||||
|
||||
```bash
|
||||
mkdir -p .docs/adrs
|
||||
```
|
||||
|
||||
Convenção de diretório: `.docs/adrs/` na raiz do monorepo.
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Criar o Arquivo ADR
|
||||
|
||||
Nomenclatura: `NNN-titulo-em-kebab-case.md`
|
||||
|
||||
```bash
|
||||
# Encontrar o próximo número
|
||||
NEXT=$(ls .docs/adrs/*.md 2>/dev/null | wc -l | xargs -I{} expr {} + 1)
|
||||
NEXT=$(printf "%03d" $NEXT)
|
||||
echo "Próximo ADR: $NEXT"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Preencher o Template
|
||||
|
||||
```markdown
|
||||
# ADR-NNN: Título Descritivo da Decisão
|
||||
|
||||
**Data:** YYYY-MM-DD
|
||||
**Status:** proposto | aceito | substituído por ADR-XXX | descontinuado
|
||||
**Autores:** Nome(s)
|
||||
|
||||
## Contexto
|
||||
|
||||
Descreva a situação que levou à necessidade de uma decisão.
|
||||
Inclua:
|
||||
- O problema enfrentado
|
||||
- Restrições técnicas ou de negócio
|
||||
- O que motivou a discussão
|
||||
|
||||
## Decisão
|
||||
|
||||
Descreva a decisão tomada de forma clara e direta.
|
||||
Use voz ativa: "Decidimos usar X para Y porque Z."
|
||||
|
||||
## Alternativas Consideradas
|
||||
|
||||
### Alternativa A: [Nome]
|
||||
- **Prós:** ...
|
||||
- **Contras:** ...
|
||||
- **Motivo da rejeição:** ...
|
||||
|
||||
### Alternativa B: [Nome]
|
||||
- **Prós:** ...
|
||||
- **Contras:** ...
|
||||
- **Motivo da rejeição:** ...
|
||||
|
||||
## Consequências
|
||||
|
||||
### Positivas
|
||||
- O que melhora com essa decisão
|
||||
|
||||
### Negativas
|
||||
- O que fica mais complexo ou limitado
|
||||
- Débitos técnicos introduzidos
|
||||
|
||||
### Neutras
|
||||
- Mudanças que não são boas nem ruins, mas afetam o workflow
|
||||
|
||||
## Impacto no Monorepo
|
||||
|
||||
Listar quais pacotes/módulos são afetados:
|
||||
- `@org/pacote-a` — precisa migrar de X para Y
|
||||
- `@org/pacote-b` — sem impacto
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Conectar com o Sistema de Conhecimento
|
||||
|
||||
Após criar o ADR, avaliar se a decisão deve gerar:
|
||||
|
||||
| A decisão... | Ação |
|
||||
|-------------|------|
|
||||
| Cria uma **restrição** permanente (ex: "nunca usar lib X") | Criar/atualizar uma **Rule** em `.agent/rules/` |
|
||||
| Define um **processo** repetível (ex: "para migrar, faça X, Y, Z") | Criar/atualizar um **Workflow** em `.agent/workflows/` |
|
||||
| Refina um **padrão operacional** (ex: "queries agora usam pool separado") | Atualizar a **Skill** correspondente em `.agent/skills/` |
|
||||
| Não gera artefato adicional | Apenas o ADR é suficiente |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 5 — Validar o ADR
|
||||
|
||||
Antes de considerar completo:
|
||||
|
||||
- **Teste do "daqui a 6 meses"**: alguém que não participou da conversa consegue entender a decisão?
|
||||
- **Teste da reversibilidade**: está claro o que seria necessário para reverter essa decisão?
|
||||
- **Teste do impacto**: todos os pacotes afetados estão listados?
|
||||
|
||||
---
|
||||
|
||||
## Exemplos de ADRs Reais
|
||||
|
||||
### Bom ✅
|
||||
|
||||
> **ADR-003: Usar Zod para validação de schemas em vez de Joi**
|
||||
>
|
||||
> **Contexto:** O projeto usava Joi para validação no backend, mas ao compartilhar schemas entre back e front em um monorepo, Joi se mostrou pesado para o bundle do frontend (280KB gzipped).
|
||||
>
|
||||
> **Decisão:** Migrar para Zod em todos os pacotes. Zod oferece inferência nativa de tipos TypeScript, é 10x menor, e elimina a necessidade de manter tipos e schemas separados.
|
||||
|
||||
### Ruim ❌
|
||||
|
||||
> **ADR-003: Usar Zod**
|
||||
>
|
||||
> Decidimos usar Zod porque é melhor.
|
||||
|
||||
---
|
||||
|
||||
## Checklist Final
|
||||
|
||||
- [ ] O contexto explica o "porquê" da decisão?
|
||||
- [ ] As alternativas consideradas estão documentadas?
|
||||
- [ ] As consequências (positivas e negativas) estão claras?
|
||||
- [ ] Os pacotes impactados estão listados?
|
||||
- [ ] O status está definido (proposto/aceito)?
|
||||
- [ ] A decisão gerou rules/workflows/skills quando aplicável?
|
||||
- [ ] Alguém de fora do contexto entenderia este ADR?
|
||||
|
||||
## Referências
|
||||
|
||||
- Workflow: `.agent/workflows/aprimorar-IA.global.md` (seção de classificação de artefatos)
|
||||
- Workflow: `.agent/workflows/otimizar-codigos.global.md`
|
||||
131
global/skills/documentar-dominio-modulo/SKILL.md
Normal file
131
global/skills/documentar-dominio-modulo/SKILL.md
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
---
|
||||
name: documentar-dominio-modulo
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
description: >
|
||||
Guia para documentar o domínio científico/técnico de cada módulo SaaS,
|
||||
garantindo que o agente compreenda a terminologia e as regras do domínio
|
||||
ao gerar código, texto e interface.
|
||||
---
|
||||
|
||||
# Skill: Documentar Domínio de um Módulo
|
||||
|
||||
Use esta skill ao iniciar um novo módulo SaaS ou ao perceber que o agente não conhece o vocabulário e as regras do domínio que o módulo aborda.
|
||||
|
||||
Cada módulo opera em uma disciplina diferente da ciência/gestão ambiental (licenciamento, gases de efeito estufa, resíduos, projetos, etc.). O agente precisa de uma **base factual do domínio** para gerar labels, mensagens, regras de negócio e textos comerciais corretos.
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Identificar o Domínio do Módulo
|
||||
|
||||
Determinar qual área da ciência/gestão o módulo aborda:
|
||||
|
||||
| Exemplo de módulo | Domínio |
|
||||
|---|---|
|
||||
| Licenciamento | Licenciamento ambiental (LP, LI, LO, condicionantes) |
|
||||
| GEE | Gases de Efeito Estufa (inventário, emissões, fatores) |
|
||||
| Resíduos | Gestão de resíduos sólidos (PGRS, MTR, classificação) |
|
||||
| Outorga | Outorga de uso de recursos hídricos |
|
||||
| Flora/Fauna | Monitoramento de biodiversidade |
|
||||
| Projetos | Gestão de projetos ambientais e consultorias |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Criar o Arquivo de Domínio
|
||||
|
||||
Criar em `.agent/memoria/dominio-<modulo>.md`:
|
||||
|
||||
```markdown
|
||||
# Domínio: <Nome do Módulo>
|
||||
|
||||
## Área de Conhecimento
|
||||
Breve descrição da disciplina (1-3 linhas).
|
||||
|
||||
## Glossário do Módulo
|
||||
|
||||
| Termo | Definição | Sigla |
|
||||
|---|---|---|
|
||||
| Licença Prévia | Autorização para planejamento do empreendimento | LP |
|
||||
| Licença de Instalação | Autorização para início das obras | LI |
|
||||
| ... | ... | ... |
|
||||
|
||||
## Entidades Principais
|
||||
|
||||
Lista das entidades de negócio do módulo com descrição e relações:
|
||||
|
||||
- **Empreendimento**: unidade física onde ocorre a atividade potencialmente poluidora
|
||||
- **Licença**: autorização ambiental vinculada a um empreendimento
|
||||
- **Condicionante**: obrigação imposta pelo órgão ambiental na licença
|
||||
- ...
|
||||
|
||||
## Legislação Aplicável
|
||||
|
||||
| Norma | Descrição | Relevância |
|
||||
|---|---|---|
|
||||
| Lei 6.938/1981 | Política Nacional do Meio Ambiente | Base legal do licenciamento |
|
||||
| Resolução CONAMA 237/1997 | Regulamenta o licenciamento ambiental | Tipos de licença, prazos |
|
||||
| ... | ... | ... |
|
||||
|
||||
## Regras de citação legal
|
||||
- Formato: "Resolução CONAMA nº 237/1997, art. 8º, inciso I"
|
||||
- Toda sigla na primeira ocorrência com nome por extenso
|
||||
- Legislação federal > estadual > municipal (hierarquia)
|
||||
|
||||
## Fluxos do Domínio
|
||||
|
||||
Descrever os processos-chave que o módulo implementa:
|
||||
|
||||
1. Solicitação de licença → Análise técnica → Emissão → Monitoramento
|
||||
2. Cadastro de condicionante → Acompanhamento de prazo → Cumprimento
|
||||
|
||||
## Vocabulário de Interface
|
||||
|
||||
Termos que devem ser usados em labels, botões e mensagens:
|
||||
|
||||
| Contexto | ❌ Genérico | ✅ Correto para o módulo |
|
||||
|---|---|---|
|
||||
| Campo de nome | "Nome" | "Razão Social do Empreendedor" |
|
||||
| Status | "Ativo/Inativo" | "Vigente/Vencida/Suspensa" |
|
||||
| Ação principal | "Criar novo" | "Solicitar nova licença" |
|
||||
| Lista vazia | "Nenhum registro" | "Nenhuma licença cadastrada" |
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Validar com o Operador
|
||||
|
||||
Antes de consolidar:
|
||||
|
||||
- [ ] Os termos do glossário estão corretos para o contexto do módulo?
|
||||
- [ ] As entidades cobrem os conceitos centrais?
|
||||
- [ ] A legislação listada é a principal (não exaustiva)?
|
||||
- [ ] O vocabulário de interface reflete como o usuário fala no dia a dia?
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Conectar com as Rules
|
||||
|
||||
Após documentar o domínio:
|
||||
|
||||
1. Verificar se labels e mensagens no código usam o vocabulário definido (rule `mensagens-usuario.global.md`)
|
||||
2. Verificar se schemas Zod têm mensagens de erro no idioma do domínio (rule `zod-validacao-padrao.global.md`)
|
||||
3. Verificar se os arquivos `.ajuda.md` usam termos do glossário (workflow `adicionar-ajuda.global.md`)
|
||||
4. Verificar se textos comerciais citam a legislação corretamente (workflow `comercial.global.md`)
|
||||
|
||||
---
|
||||
|
||||
## Checklist Final
|
||||
|
||||
- [ ] Arquivo `dominio-<modulo>.md` criado em `.agent/memoria/`?
|
||||
- [ ] Glossário com pelo menos os 10 termos centrais do módulo?
|
||||
- [ ] Entidades principais listadas com descrição?
|
||||
- [ ] Legislação base documentada com formato de citação?
|
||||
- [ ] Vocabulário de interface definido (labels, status, ações, empty states)?
|
||||
- [ ] Operador validou a terminologia?
|
||||
|
||||
## Referências
|
||||
|
||||
- Rule: `.agent/rules/mensagens-usuario.global.md`
|
||||
- Rule: `.agent/rules/regras-negocio-md.global.md`
|
||||
- Workflow: `.agent/workflows/comercial.global.md`
|
||||
- Workflow: `.agent/workflows/adicionar-ajuda.global.md`
|
||||
212
global/skills/documentar-regras-negocio/SKILL.md
Normal file
212
global/skills/documentar-regras-negocio/SKILL.md
Normal file
|
|
@ -0,0 +1,212 @@
|
|||
---
|
||||
name: documentar-regras-negocio
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
description: >
|
||||
Guia operacional para criar, preencher e manter arquivos {modulo}.regras-negocio.md
|
||||
co-localizados com módulos TypeScript de lógica de negócio complexa.
|
||||
---
|
||||
|
||||
# Skill: Documentar Regras de Negócio em Módulos
|
||||
|
||||
Use esta skill sempre que um módulo TypeScript contiver lógica de decisão não-trivial
|
||||
que precise ser rastreável por produto, suporte e desenvolvimento sem exigir leitura de código.
|
||||
|
||||
---
|
||||
|
||||
## Quando usar esta skill
|
||||
|
||||
- Módulo com 3+ critérios de decisão distintos
|
||||
- Lógica de eleição/priorização entre registros
|
||||
- Processamento que pode resultar em revisão manual
|
||||
- Worker/CRON consumindo dados com estratégias diferenciadas por tipo
|
||||
- Importador automático com regras de aceite/rejeição
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Identificar o escopo das regras
|
||||
|
||||
Antes de escrever o `.md`, percorrer o módulo e identificar:
|
||||
|
||||
| Categoria | O que procurar |
|
||||
|---|---|
|
||||
| **Critérios de entrada** | Filtros de query (excluido, vencimento, etc.) |
|
||||
| **Critérios de bloqueio** | Condições que bloqueiam o fluxo automático |
|
||||
| **Estratégia por tipo de dado** | Concatenação vs. primeiro-não-nulo vs. outros |
|
||||
| **Eleição de principal** | Regras de prioridade entre registros |
|
||||
| **Estado contraditório** | Combinações de campos mutuamente exclusivas |
|
||||
| **Dependências externas** | Tabelas, filas, serviços tocados |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Criar o arquivo
|
||||
|
||||
Nomenclatura: `{nome-do-modulo-sem-underline-inicial}.regras-negocio.md`
|
||||
|
||||
Localizar **na mesma pasta** do arquivo TypeScript:
|
||||
|
||||
```
|
||||
modulo/
|
||||
_meuModulo.ts
|
||||
meu-modulo.regras-negocio.md ← co-localizado
|
||||
```
|
||||
|
||||
Se o módulo for arquivo isolado (não pasta):
|
||||
```
|
||||
CRONS/
|
||||
_cron_nome.ts
|
||||
_cron_nome.regras-negocio.md ← mesmo diretório
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Preencher com o template
|
||||
|
||||
```markdown
|
||||
# Regras de Negócio — [Nome Legível do Módulo]
|
||||
|
||||
Módulo: `_arquivo.ts`
|
||||
Localização: `caminho/relativo/ao/workspace`
|
||||
|
||||
---
|
||||
|
||||
## Contexto
|
||||
|
||||
[Por que este módulo existe. Qual problema de negócio resolve.
|
||||
Inclua o cenário que levou à sua criação — ex: "O sistema pode gerar duplicatas
|
||||
por importações simultâneas..."]
|
||||
|
||||
---
|
||||
|
||||
## Critérios de Entrada
|
||||
|
||||
[O que aciona o módulo. Filtros aplicados na query de identificação.
|
||||
Ex: `excluido = false`, mesmo `(codigo_origem, vencimento)`, etc.]
|
||||
|
||||
---
|
||||
|
||||
## Regras de Processamento
|
||||
|
||||
[Numeradas em ordem de avaliação. Cada regra deve incluir:
|
||||
- Condição de ativação
|
||||
- O que acontece quando ativada
|
||||
- Se bloqueia ou direciona]
|
||||
|
||||
### Regra 1 — [Nome]
|
||||
...
|
||||
|
||||
### Regra 2 — [Nome]
|
||||
...
|
||||
|
||||
---
|
||||
|
||||
## Casos de Revisão Manual
|
||||
|
||||
[Quando o fluxo automático não pode prosseguir.
|
||||
Liste as condições que enviam para revisão manual.
|
||||
Se aplicável: como o caso é reportado (e-mail, log, fila de revisão).]
|
||||
|
||||
> **`null` é neutro** quando aplicável: descrever aqui se a lógica usa null como ausência neutra.
|
||||
|
||||
---
|
||||
|
||||
## Estratégia de Saída / Fusão de Campos
|
||||
|
||||
[Como os dados são combinados ou qual resultado é produzido.
|
||||
Usar tabela para clareza:]
|
||||
|
||||
| Campo | Estratégia |
|
||||
|---|---|
|
||||
| `campo_textual` | Concatenação sem repetição |
|
||||
| `campo_data` | Primeiro valor não-nulo vence |
|
||||
| `campo_booleano` | Primeiro valor não-nulo vence |
|
||||
|
||||
---
|
||||
|
||||
## Dependências Externas
|
||||
|
||||
[Tabelas lidas/escritas, filas disparadas, serviços externos.
|
||||
Incluir colunas de relacionamento quando relevante.]
|
||||
|
||||
- Tabelas de negócio: `tabela_a`, `tabela_b`
|
||||
- Relacionamentos re-apontados: `tabela_c` via `(codigo_origem, tabela_origem)`
|
||||
- Filas: nenhuma / `nome-da-fila`
|
||||
- E-mails: nenhum / destinatários e gatilho
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Adicionar referência no módulo TypeScript
|
||||
|
||||
Na **primeira linha útil** do arquivo `.ts` (após shebang ou licença, se houver):
|
||||
|
||||
```typescript
|
||||
// Regras de negócio: ver {modulo}.regras-negocio.md
|
||||
|
||||
import { ... } from "..."
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 5 — Limpar JSDoc duplicados
|
||||
|
||||
Percorrer os JSDoc do módulo e:
|
||||
|
||||
| Se encontrar | Ação |
|
||||
|---|---|
|
||||
| JSDoc listando as regras de negócio | Substituir por referência ao `.md` |
|
||||
| JSDoc descrevendo critérios de bloqueio | Simplificar para "ver `.md`" |
|
||||
| JSDoc com listas de condições | Manter apenas `@param` e `@returns` |
|
||||
| Comentário inline explicando uma regra | Manter — comentários de linha são aceitáveis |
|
||||
|
||||
Exemplo de simplificação:
|
||||
|
||||
```typescript
|
||||
// ❌ Antes — JSDoc duplicando as regras
|
||||
/**
|
||||
* Retorna false quando:
|
||||
* - vencimentos divergentes
|
||||
* - executada com datas distintas e não-nulas
|
||||
* - vencimento_prorrogado distintos
|
||||
* - estado contraditório: nao_executada=true + executada!=null
|
||||
*/
|
||||
|
||||
// ✅ Depois — referência ao .md
|
||||
/**
|
||||
* Verifica se o grupo pode ser fundido e elege o registro principal.
|
||||
* Critérios de bloqueio e regras de eleição: ver regras-negocio.md
|
||||
*
|
||||
* @param execs - Registros do grupo, ordenados do mais antigo para o mais recente
|
||||
* @returns Código do eleito, ou `undefined` quando o grupo vai para revisão manual
|
||||
*/
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 6 — Verificar consistência código ↔ `.md`
|
||||
|
||||
Percorrer cada regra listada no `.md` e verificar que há código correspondente:
|
||||
|
||||
- [ ] Cada critério de bloqueio tem um `if (...) return undefined / return retornoVazio`
|
||||
- [ ] Cada estratégia de campo tem implementação em `fundirCampos` ou equivalente
|
||||
- [ ] A ordem de avaliação no código bate com a ordem no `.md`
|
||||
- [ ] Campos exclusivos de certas tabelas estão guardados pelo `if (tabela === ...)`
|
||||
- [ ] queries têm `orderBy` quando a posição dos resultados tem significado (ver skill `consultar-banco-knex`)
|
||||
|
||||
---
|
||||
|
||||
## Checklist Final
|
||||
|
||||
- [ ] Arquivo `.md` criado co-localizado com o módulo
|
||||
- [ ] Referência `// Regras de negócio: ver ...` na primeira linha do `.ts`
|
||||
- [ ] JSDoc simplificados — sem duplicar conteúdo do `.md`
|
||||
- [ ] Todas as regras do `.md` têm implementação correspondente no código
|
||||
- [ ] Código e `.md` estão consistentes (separadores, campos, condições)
|
||||
- [ ] `tsc --noEmit` passa sem erros após qualquer mudança de código
|
||||
|
||||
---
|
||||
|
||||
## Referências
|
||||
|
||||
- Rule: `.agent/rules/regras-negocio-md.global.md`
|
||||
- Workflow: `.agent/workflows/documentar-regras-negocio.global.md`
|
||||
160
global/skills/mapear-codigo-fonte/SKILL.md
Normal file
160
global/skills/mapear-codigo-fonte/SKILL.md
Normal file
|
|
@ -0,0 +1,160 @@
|
|||
---
|
||||
name: mapear-codigo-fonte
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
description: >
|
||||
Guia operacional para mapear, navegar e compreender a estrutura de um monorepo TypeScript.
|
||||
---
|
||||
|
||||
# Skill: Mapear Código-Fonte de Monorepo TypeScript
|
||||
|
||||
Use esta skill ao iniciar trabalho em um monorepo desconhecido, ao onboardar em novo projeto, ou quando precisar localizar rapidamente onde uma funcionalidade vive no código.
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Identificar a Raiz e o Gerenciador de Pacotes
|
||||
|
||||
Localize os arquivos que definem a estratégia de monorepo:
|
||||
|
||||
```bash
|
||||
# Identificar o gerenciador e workspace config
|
||||
ls -la package.json pnpm-workspace.yaml lerna.json turbo.json nx.json tsconfig.base.json 2>/dev/null
|
||||
```
|
||||
|
||||
Elementos a extrair:
|
||||
|
||||
- **Gerenciador**: `pnpm` (workspaces em `pnpm-workspace.yaml`), `npm/yarn` (workspaces em `package.json`), ou `nx`/`turbo`
|
||||
- **Pacotes compartilhados**: diretórios listados em `packages:` ou `workspaces:`
|
||||
- **Apps/serviços**: diretórios de aplicações deployáveis
|
||||
- **TSConfig base**: herança de configuração TypeScript entre pacotes
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Mapear a Árvore de Pacotes
|
||||
|
||||
```bash
|
||||
# Listar todos os pacotes do workspace com nomes e caminhos
|
||||
# pnpm
|
||||
pnpm ls --depth -1 -r --json 2>/dev/null | jq '.[].name'
|
||||
|
||||
# Alternativa genérica: encontrar todos os package.json
|
||||
fd package.json --max-depth 3 --type f --exec sh -c 'echo "$(dirname {}): $(jq -r .name {})"'
|
||||
```
|
||||
|
||||
Organizar os pacotes em categorias:
|
||||
|
||||
| Categoria | Padrão de nome | Exemplo |
|
||||
|-----------|---------------|---------|
|
||||
| **Libs compartilhadas** | `@org/common`, `*-comuns`, `*-shared` | Tipos, utils, schemas |
|
||||
| **Backend** | `*-back`, `*-api`, `*-server` | Serviços Node/Express/Fastify |
|
||||
| **Frontend** | `*-front`, `*-web`, `*-app` | Apps Vue/React/Angular |
|
||||
| **Ferramentas** | `*-cli`, `*-scripts`, `*-tools` | Scripts de build, migrations |
|
||||
| **Configs** | `*-config`, `*-eslint-config` | Configs compartilhadas |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Mapear Dependências Internas
|
||||
|
||||
Identificar o grafo de dependências entre pacotes internos:
|
||||
|
||||
```bash
|
||||
# Para cada package.json, listar deps internas (que apontam para workspace:)
|
||||
rg '"workspace:' --include='package.json' -l | while read f; do
|
||||
echo "=== $(jq -r .name "$f") ==="
|
||||
jq -r '.dependencies // {} | to_entries[] | select(.value | startswith("workspace:")) | .key' "$f"
|
||||
jq -r '.devDependencies // {} | to_entries[] | select(.value | startswith("workspace:")) | .key' "$f"
|
||||
done
|
||||
```
|
||||
|
||||
Anotar:
|
||||
|
||||
- Quais pacotes são **folha** (não dependem de outros internos)
|
||||
- Quais são **raiz** (ninguém depende deles — geralmente apps)
|
||||
- Quais são **núcleo** (muitos dependem deles — geralmente libs compartilhadas)
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Mapear Arquitetura de Cada Pacote
|
||||
|
||||
Para cada pacote relevante, identificar a estrutura interna:
|
||||
|
||||
```bash
|
||||
# Visão geral rápida (2 níveis de profundidade)
|
||||
eza --tree --level=2 --icons --group-directories-first <caminho-do-pacote>/src/
|
||||
# ou
|
||||
tree -L 2 -I node_modules <caminho-do-pacote>/src/
|
||||
```
|
||||
|
||||
Padrões comuns a procurar:
|
||||
|
||||
| Diretório | Responsabilidade típica |
|
||||
|-----------|----------------------|
|
||||
| `src/routes/` ou `src/api/` | Endpoints/rotas HTTP |
|
||||
| `src/services/` | Lógica de negócio |
|
||||
| `src/models/` ou `src/entities/` | Modelos de dados |
|
||||
| `src/utils/` ou `src/helpers/` | Funções utilitárias |
|
||||
| `src/types/` ou `src/typings/` | Definições de tipos TS |
|
||||
| `src/schemas/` | Schemas de validação (Zod, Joi) |
|
||||
| `src/migrations/` | Migrações de banco |
|
||||
| `src/components/` | Componentes de UI (frontend) |
|
||||
| `src/composables/` ou `src/hooks/` | Lógica reutilizável (Vue/React) |
|
||||
| `src/stores/` | Gerenciamento de estado |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 5 — Identificar Pontos de Entrada e Exportações
|
||||
|
||||
```bash
|
||||
# Encontrar exports públicos de cada pacote
|
||||
rg "export " --include='index.ts' --include='index.tsx' -l
|
||||
|
||||
# Encontrar entry points no package.json
|
||||
fd package.json --max-depth 3 --type f --exec sh -c 'echo "$(jq -r .name {}):" && jq "{main, module, types, exports}" {}'
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 6 — Documentar o Mapa
|
||||
|
||||
Produzir um resumo estruturado com:
|
||||
|
||||
```markdown
|
||||
# Mapa do Monorepo: <nome>
|
||||
|
||||
## Gerenciador: pnpm | npm | yarn
|
||||
## Build System: tsc | turbo | nx
|
||||
|
||||
## Pacotes
|
||||
|
||||
### Libs Compartilhadas
|
||||
- `@org/types` → tipos compartilhados (depende de: nenhum)
|
||||
- `@org/utils` → funções utilitárias (depende de: @org/types)
|
||||
|
||||
### Aplicações
|
||||
- `@org/api` → backend Express (depende de: @org/types, @org/utils)
|
||||
- `@org/web` → frontend Vue (depende de: @org/types)
|
||||
|
||||
## Fluxo de dados
|
||||
Descrever como os dados fluem entre pacotes.
|
||||
|
||||
## Scripts importantes
|
||||
- `pnpm build` → Build de todos os pacotes
|
||||
- `pnpm dev` → Inicia dev server
|
||||
- `pnpm test` → Roda testes
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Checklist Final
|
||||
|
||||
- [ ] O gerenciador de pacotes e workspace strategy estão identificados?
|
||||
- [ ] Todos os pacotes foram categorizados (lib/app/tool)?
|
||||
- [ ] O grafo de dependências internas foi mapeado?
|
||||
- [ ] Os pontos de entrada de cada pacote estão claros?
|
||||
- [ ] A arquitetura interna dos pacotes principais foi documentada?
|
||||
- [ ] Scripts de build/dev/test foram identificados?
|
||||
|
||||
## Referências
|
||||
|
||||
- Rules: `.agent/rules/typescript-sem-any.global.md`
|
||||
- Workflow: `.agent/workflows/otimizar-codigos.global.md`
|
||||
177
global/skills/orquestrar-agentes/SKILL.md
Normal file
177
global/skills/orquestrar-agentes/SKILL.md
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
---
|
||||
name: orquestrar-agentes
|
||||
description: >
|
||||
Protocolo de colaboração e handoff entre agentes especializados do ecossistema Azteca.
|
||||
Define como agentes passam contexto, comunicam resultados e resolvem dependências.
|
||||
scope: global
|
||||
---
|
||||
|
||||
# Skill: Orquestrar Agentes
|
||||
|
||||
Use esta skill sempre que uma tarefa exigir a colaboração de dois ou mais agentes especializados, ou quando precisar entender quem deve fazer o quê em uma implementação complexa.
|
||||
|
||||
---
|
||||
|
||||
## PASSO 1 — Identificar os agentes envolvidos
|
||||
|
||||
Antes de qualquer implementação, mapear quais agentes são necessários:
|
||||
|
||||
| Tarefa | Agente responsável |
|
||||
|--------|-------------------|
|
||||
| Definir arquitetura, contratos de API, schemas | `@ag-arquiteto` |
|
||||
| Implementar backend (rotas, serviços, banco) | `@ag-back` |
|
||||
| Implementar frontend (telas, componentes, fluxos) | `@ag-front` |
|
||||
| Garantir qualidade e criar testes | `@ag-testes` |
|
||||
| Configurar infraestrutura e deploy | `@ag-deploy` |
|
||||
| Criar/atualizar documentação | `@ag-documentacao` |
|
||||
| Revisar e melhorar UX | `@ag-ux` |
|
||||
| Criar materiais de venda e marketing | `@ag-comercial` |
|
||||
|
||||
---
|
||||
|
||||
## PASSO 2 — Definir a sequência de handoff
|
||||
|
||||
Toda tarefa complexa segue uma ordem de precedência:
|
||||
|
||||
```
|
||||
1. @ag-arquiteto → define e especifica
|
||||
2. @ag-back → implementa backend + schemas *-comuns
|
||||
3. @ag-front → implementa frontend (consome *-comuns)
|
||||
4. @ag-ux → revisa experiência (paralelo com front)
|
||||
5. @ag-testes → valida qualidade
|
||||
6. @ag-deploy → empacota e publica
|
||||
7. @ag-documentacao → documenta (pode ser paralelo)
|
||||
8. @ag-comercial → cria materiais (após documentação)
|
||||
```
|
||||
|
||||
Agentes podem trabalhar em paralelo quando não há dependência direta:
|
||||
- `@ag-ux` e `@ag-front` podem colaborar em paralelo
|
||||
- `@ag-documentacao` pode trabalhar em paralelo com `@ag-testes`
|
||||
- `@ag-comercial` é sempre o último da cadeia
|
||||
|
||||
---
|
||||
|
||||
## PASSO 3 — Formato de mensagem entre agentes
|
||||
|
||||
Quando um agente precisa comunicar resultado ou delegar tarefa para outro, usar o formato:
|
||||
|
||||
```markdown
|
||||
**De:** @ag-arquiteto
|
||||
**Para:** @ag-back
|
||||
**Tipo:** especificação | resultado | bloqueio | revisão
|
||||
|
||||
## Contexto
|
||||
[O que foi decidido/implementado/identificado]
|
||||
|
||||
## Entrega
|
||||
[O que o agente destinatário precisa fazer ou receber]
|
||||
|
||||
## Dependências
|
||||
[Arquivos, schemas, endpoints ou decisões que o destinatário precisa conhecer]
|
||||
|
||||
## Critérios de aceite
|
||||
[Como saber que a tarefa do destinatário está completa]
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 4 — Regras de escopo entre agentes
|
||||
|
||||
### Permitido ✅
|
||||
|
||||
```
|
||||
@ag-arquiteto → pode delegar para qualquer agente
|
||||
@ag-back → pode enviar schemas e endpoints para @ag-front (via *-comuns)
|
||||
@ag-front → pode solicitar revisão de @ag-ux
|
||||
@ag-ux → pode propor melhorias para @ag-front
|
||||
@ag-testes → pode reportar bugs para @ag-back e @ag-front
|
||||
@ag-documentacao → pode documentar artefatos de qualquer agente
|
||||
@ag-deploy → recebe builds de @ag-back e @ag-front
|
||||
```
|
||||
|
||||
### Proibido ❌
|
||||
|
||||
```
|
||||
@ag-front ✗ não importa código de @ag-back diretamente
|
||||
@ag-back ✗ não cria componentes Vue ou lógica de interface
|
||||
@ag-comercial ✗ não promete features que @ag-arquiteto não aprovou
|
||||
@ag-testes ✗ não modifica código de produção
|
||||
@ag-ux ✗ não implementa código Vue — apenas orienta @ag-front
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## PASSO 5 — Resolução de conflitos
|
||||
|
||||
Quando dois agentes têm visões diferentes:
|
||||
|
||||
1. **Técnico vs. UX:** `@ag-arquiteto` arbitra, priorizando viabilidade técnica com mínimo impacto na UX
|
||||
2. **Back vs. Front (sobre contrato de API):** `@ag-arquiteto` define o contrato no schema `*-comuns`
|
||||
3. **Documentação vs. Implementação:** O código é a verdade — `@ag-documentacao` atualiza para refletir o código
|
||||
4. **Comercial vs. Produto:** `@ag-arquiteto` define o que existe; `@ag-comercial` comunica apenas o real
|
||||
|
||||
---
|
||||
|
||||
## PASSO 6 — Fluxos típicos de colaboração
|
||||
|
||||
### Fluxo: Nova feature completa
|
||||
|
||||
```
|
||||
@ag-arquiteto → especifica schema e contrato de API
|
||||
↓
|
||||
@ag-back → implementa endpoint + atualiza *-comuns
|
||||
↓
|
||||
@ag-front → implementa tela consumindo *-comuns
|
||||
↓ (paralelo)
|
||||
@ag-ux → revisa UX da tela
|
||||
↓
|
||||
@ag-testes → valida back + front
|
||||
↓
|
||||
@ag-deploy → publica
|
||||
↓ (paralelo)
|
||||
@ag-documentacao → documenta
|
||||
↓
|
||||
@ag-comercial → cria material de divulgação
|
||||
```
|
||||
|
||||
### Fluxo: Correção de bug crítico
|
||||
|
||||
```
|
||||
@ag-testes → identifica e documenta bug
|
||||
↓
|
||||
@ag-back ou @ag-front → corrige
|
||||
↓
|
||||
@ag-testes → valida correção
|
||||
↓
|
||||
@ag-deploy → hotfix
|
||||
```
|
||||
|
||||
### Fluxo: Melhoria de UX
|
||||
|
||||
```
|
||||
@ag-ux → identifica problema e propõe melhoria
|
||||
↓
|
||||
@ag-arquiteto → avalia impacto técnico
|
||||
↓
|
||||
@ag-front → implementa
|
||||
↓
|
||||
@ag-ux → valida
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Checklist de orquestração
|
||||
|
||||
- [ ] Agentes necessários identificados?
|
||||
- [ ] Sequência de handoff definida?
|
||||
- [ ] Dependências entre agentes mapeadas?
|
||||
- [ ] Critérios de aceite definidos para cada entrega?
|
||||
- [ ] Conflitos potenciais identificados e árbitro definido?
|
||||
|
||||
---
|
||||
|
||||
## Referências
|
||||
|
||||
- Rules: `.agent/global/rules/autonomia-agente.md`
|
||||
- Rules: `.agent/global/rules/fronteiras-monorepo.md`
|
||||
- Personas: `.agent/agents/*/persona.md`
|
||||
263
global/workflows/aprimorar-IA.md
Normal file
263
global/workflows/aprimorar-IA.md
Normal file
|
|
@ -0,0 +1,263 @@
|
|||
---
|
||||
type: workflow
|
||||
name: aprimorar-IA
|
||||
description: Consolidar aprendizados da conversa atual e evoluir continuamente as regras, skills e fluxos da aplicação
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Workflow: Aprimorar Conhecimento da Aplicação
|
||||
|
||||
## 🎯 Objetivo
|
||||
|
||||
Garantir que **toda decisão tomada** seja imediatamente incorporada ao conhecimento estruturado da aplicação, mantendo o sistema de rules, workflows e skills **coerente, atualizado, não redundante e sem contradições**.
|
||||
|
||||
Este workflow é **obrigatório** e deve ser executado sempre que houver qualquer definição nova.
|
||||
|
||||
---
|
||||
|
||||
## Artefatos de Conhecimento
|
||||
|
||||
O conhecimento do agente está organizado em **três tipos de artefatos**, cada um com responsabilidade distinta:
|
||||
|
||||
| Artefato | Diretório | Responsabilidade |
|
||||
|----------|-----------|------------------|
|
||||
| **Rules** | `.agent/rules/` | Restrições e convenções que o agente **deve respeitar sempre** |
|
||||
| **Workflows** | `.agent/workflows/` | Processos sequenciais com passos numerados para tarefas bem definidas |
|
||||
| **Skills** | `.agent/skills/` | Guias operacionais completos e reutilizáveis para tarefas complexas recorrentes |
|
||||
| **Memória** | `.agent/memoria/` | Registros históricos, contexto do projeto, fatos e decisões importantes |
|
||||
|
||||
### Diferenças entre os artefatos
|
||||
|
||||
| Critério | Rule | Workflow | Skill | Memória |
|
||||
|----------|------|----------|-------|---------|
|
||||
| **Formato** | Regra declarativa | Passos sequenciais | Guia prático com templates | Diários, ADRs, documentação de contexto puro |
|
||||
| **Quando usar** | Aplicada **automaticamente** em todo contexto | Acionado por **comando** (`/workflow`) | Consultado **sob demanda** ao iniciar tarefa complexa | Consultado **para restaurar contexto** e entender escopo |
|
||||
| **Exemplos** | "Nunca usar `any`" | "/migracao_banco" | "Criar função api2 end-to-end" | "ADR de transição para Nuxt 4", "Dicionário de dados" |
|
||||
| **Escopo** | Restrição transversal | Processo pontual | Padrão operacional completo | Registro histórico e base factual |
|
||||
|
||||
### Regra de escolha
|
||||
|
||||
- Se é uma **restrição** que vale sempre → **Rule**
|
||||
- Se é um **processo com etapas** que o usuário aciona → **Workflow**
|
||||
- Se é um **guia operacional** com templates e checklist para tarefas complexas → **Skill**
|
||||
- Se o conteúdo serve como **referência cruzada** durante tarefas → **Skill**
|
||||
- Se é um **registro de estado, decisão técnica importante ou compreensão do domínio temporal** → **Memória**
|
||||
|
||||
---
|
||||
|
||||
## 1️⃣ Análise do Contexto Atual (Obrigatória)
|
||||
|
||||
É obrigatório:
|
||||
|
||||
- Revisar integralmente a conversa atual.
|
||||
- Identificar:
|
||||
- Regras de negócio novas ou alteradas.
|
||||
- Padrões técnicos definidos.
|
||||
- Convenções estabelecidas.
|
||||
- Decisões arquiteturais.
|
||||
- Ajustes de comportamento do sistema ou do agente.
|
||||
|
||||
Para cada item identificado, classificar obrigatoriamente:
|
||||
|
||||
- Já existe artefato correspondente (rule, workflow ou skill) → **ATUALIZAR**
|
||||
- Existe parcialmente → **REFATORAR**
|
||||
- Não existe → **CRIAR**
|
||||
- Impacta múltiplas áreas → **PROPAGAR**
|
||||
|
||||
---
|
||||
|
||||
## 2️⃣ Atualização das Rules (Obrigatória)
|
||||
|
||||
### Regras inegociáveis:
|
||||
|
||||
- Toda nova regra **DEVE** ser registrada.
|
||||
- Nenhuma regra pode existir apenas na conversa.
|
||||
- É **PROIBIDO** deixar conhecimento implícito.
|
||||
|
||||
### Estrutura obrigatória:
|
||||
|
||||
- Um arquivo = um único assunto.
|
||||
- Nome claro em `kebab-case`.
|
||||
- Limite máximo: ~10.000 caracteres.
|
||||
|
||||
### É obrigatório:
|
||||
|
||||
- Evitar duplicação de conteúdo.
|
||||
- Atualizar regras antigas quando substituídas.
|
||||
- Remover ou ajustar regras conflitantes.
|
||||
- Garantir consistência semântica entre arquivos.
|
||||
|
||||
### Estrutura obrigatória da rule:
|
||||
|
||||
```md
|
||||
# Nome da Regra
|
||||
|
||||
## Contexto
|
||||
Quando se aplica.
|
||||
|
||||
## Regra
|
||||
Definição objetiva e obrigatória.
|
||||
|
||||
## Exemplos
|
||||
✅ Correto
|
||||
❌ Incorreto
|
||||
|
||||
## Impacto
|
||||
Problema que evita.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 3️⃣ Atualização dos Workflows (Obrigatória quando aplicável)
|
||||
|
||||
Sempre que houver processo repetível identificado:
|
||||
|
||||
* Criar ou atualizar workflow em `.agent/workflows/`.
|
||||
|
||||
### Obrigatório:
|
||||
|
||||
* Frontmatter com `description`.
|
||||
* Passos numerados.
|
||||
* Clareza operacional (sem ambiguidade).
|
||||
* Comandos executáveis quando possível.
|
||||
* Uso de `// turbo` para comandos seguros.
|
||||
|
||||
---
|
||||
|
||||
## 4️⃣ Atualização das Skills (Obrigatória quando aplicável)
|
||||
|
||||
Sempre que um padrão operacional complexo for definido, refinado ou corrigido:
|
||||
|
||||
* Criar ou atualizar skill em `.agent/skills/<nome-da-skill>/SKILL.md`.
|
||||
|
||||
### Quando atualizar uma skill:
|
||||
|
||||
- Nova regra afeta o padrão operacional descrito na skill (ex: nova convenção de tipagem afeta `criar-funcao-api2`)
|
||||
- Novo workflow introduz etapas que complementam ou substituem uma skill
|
||||
- Um erro recorrente revela que a skill está incompleta ou desatualizada
|
||||
- Uma decisão arquitetural muda o fluxo descrito na skill
|
||||
|
||||
### Estrutura obrigatória da skill:
|
||||
|
||||
```md
|
||||
---
|
||||
name: nome-da-skill
|
||||
description: >
|
||||
Descrição em uma linha do que a skill faz.
|
||||
---
|
||||
|
||||
# Skill: Nome Descritivo
|
||||
|
||||
Parágrafo de contexto explicando quando usar.
|
||||
|
||||
## PASSO N — Título do Passo
|
||||
Instruções com código, regras e padrões.
|
||||
|
||||
## Checklist Final
|
||||
- [ ] Item de verificação
|
||||
|
||||
## Referências
|
||||
- Regras: `.agent/rules/xxx.md`
|
||||
- Workflow: `.agent/workflows/xxx.md`
|
||||
```
|
||||
|
||||
### Regras de organização:
|
||||
|
||||
- Uma skill por diretório: `.agent/skills/<nome>/SKILL.md`
|
||||
- Skills globais são identificadas pelo campo `scope: global` no frontmatter
|
||||
- Nome do diretório em `kebab-case`
|
||||
- A skill **não deve duplicar** conteúdo de rules — referencia-as via seção `Referências`
|
||||
- A skill **pode consolidar** conhecimento de múltiplas rules e workflows em um guia unificado
|
||||
- Templates de código devem estar na própria skill (não em arquivos separados, a menos que sejam muito grandes)
|
||||
|
||||
### Skills globais (distribuídas via `atualizar-agente.global.sh`):
|
||||
|
||||
| Skill | Escopo |
|
||||
|-------|--------|
|
||||
| `mapear-codigo-fonte` | Mapear e navegar a estrutura de qualquer monorepo TS |
|
||||
| `diagnosticar-erros-build` | Diagnosticar erros de build em cascata entre pacotes |
|
||||
| `documentar-decisao-tecnica` | Registrar decisões técnicas como ADRs |
|
||||
|
||||
### Skills de projeto (criadas localmente em cada monorepo):
|
||||
|
||||
Cada projeto pode criar skills adicionais específicas em `.agent/skills/<nome>/SKILL.md`.
|
||||
Essas skills focam nos padrões e domínios exclusivos daquele projeto.
|
||||
|
||||
Exemplos de skills de projeto:
|
||||
|
||||
| Skill | Escopo |
|
||||
|-------|--------|
|
||||
| `criar-funcao-api` | Função de API end-to-end (comuns → back → front) |
|
||||
| `criar-componente-vue3` | Componente Vue 3 com padrões obrigatórios do projeto |
|
||||
| `consultar-banco-knex` | Queries Knex com padrões de leitura/escrita/JSONB |
|
||||
| `implementar-permissoes` | Controle de acesso específico do domínio |
|
||||
|
||||
---
|
||||
|
||||
## 5️⃣ Atualização da Memória (Obrigatória quando aplicável)
|
||||
|
||||
Sempre que decisões críticas sobre a arquitetura da aplicação ou o contexto do domínio precisarem ser arquivadas temporária ou permanentemente de maneira descritiva (e não diretamente injetável em código ou regra de lint):
|
||||
|
||||
* Registre o novo documento no formato adequado mantendo a pasta limpa em `.agent/memoria/`.
|
||||
* Exemplo: Manter diário de pendências (`diario-pendencias-modulo-x.md`) ou ADR (`adr-001-migracao-nuxt-4.md`).
|
||||
* Atenção! Tudo que puder ser abstraído para formato técnico estrito deve virar **Skill** ou **Rule**. Use a Memória apenas como extensão de base factual.
|
||||
|
||||
---
|
||||
|
||||
## 6️⃣ Revisão de Impacto (Dirigida por Grafo)
|
||||
|
||||
Quando um artefato é alterado, a revisão deve ser **dirigida**, não exaustiva.
|
||||
|
||||
### Processo:
|
||||
|
||||
1. Identificar o artefato alterado
|
||||
2. Consultar a seção `Referências` do artefato para encontrar dependentes diretos
|
||||
3. Verificar consistência APENAS entre o artefato alterado e seus dependentes
|
||||
4. Se uma inconsistência for encontrada, propagar para o próximo nível
|
||||
|
||||
### Regras de escopo:
|
||||
|
||||
| Se alterou... | Revisar... |
|
||||
|---|---|
|
||||
| Uma **Rule** | Workflows e skills que a **referenciam** |
|
||||
| Um **Workflow** | Skills que o **referenciam** |
|
||||
| Uma **Skill** | Rules e workflows na seção Referências |
|
||||
| **Memória/ADR** | Nada — memória é registro, não dependência |
|
||||
|
||||
### É PROIBIDO:
|
||||
|
||||
* Revisar artefatos **sem relação** com a mudança
|
||||
* Afirmar que "tudo foi revisado" sem listar quais artefatos foram verificados
|
||||
* Criar artefatos sem verificar se já existe um com o mesmo escopo
|
||||
|
||||
### A revisão DEVE verificar:
|
||||
|
||||
* Não existem regras conflitantes entre o artefato alterado e seus dependentes
|
||||
* Referências cruzadas continuam válidas (arquivos existem, nomes corretos)
|
||||
* Skills refletem fielmente as rules que referenciam
|
||||
* Não há duplicação de conteúdo entre artefatos
|
||||
|
||||
---
|
||||
|
||||
## 7⃣ Verificação Final (Checklist obrigatório)
|
||||
|
||||
Só é permitido encerrar se TODOS forem verdadeiros:
|
||||
|
||||
* [ ] Artefatos dependentes do alterado foram revisados
|
||||
* [ ] Não existe conflito entre artefatos revisados
|
||||
* [ ] Não existe duplicação de conteúdo
|
||||
* [ ] Nenhuma regra ficou implícita
|
||||
* [ ] Referências cruzadas estão válidas
|
||||
* [ ] Estrutura está organizada por assunto
|
||||
* [ ] Skills referenciam (não duplicam) rules
|
||||
|
||||
---
|
||||
|
||||
## ⚠️ Regra Suprema
|
||||
|
||||
> Se existir qualquer dúvida, conflito ou inconsistência
|
||||
> entre o artefato alterado e seus dependentes,
|
||||
> o trabalho é considerado **INCOMPLETO**.
|
||||
|
||||
A revisão é dirigida, não opcional.
|
||||
105
global/workflows/documentar-regras-negocio.md
Normal file
105
global/workflows/documentar-regras-negocio.md
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
---
|
||||
type: workflow
|
||||
name: documentar-regras-negocio
|
||||
description: Criar ou atualizar o arquivo {modulo}.regras-negocio.md co-localizado com um módulo TypeScript e garantir consistência entre código e documentação
|
||||
scope: global
|
||||
updatedAt: "2026-06-01"
|
||||
---
|
||||
|
||||
# Workflow: Documentar Regras de Negócio de um Módulo
|
||||
|
||||
Use este workflow com `/documentar-regras-negocio.global` para criar ou atualizar o arquivo
|
||||
`{modulo}.regras-negocio.md` de qualquer módulo TypeScript com lógica de negócio não-trivial.
|
||||
|
||||
---
|
||||
|
||||
[1] Ler o módulo TypeScript completamente
|
||||
|
||||
Identificar e anotar:
|
||||
|
||||
- Nome do arquivo e localização exata
|
||||
- Funções exportadas e suas responsabilidades
|
||||
- Todos os `if` que representam critérios de decisão
|
||||
- Campos lidos e gravados (especialmente JSONB e campos de status)
|
||||
- Queries de banco: tabelas acessadas, filtros aplicados, joins
|
||||
- Caminhos alternativos (revisão manual, erros, skips)
|
||||
- Dependências externas (filas, e-mails, serviços)
|
||||
|
||||
---
|
||||
|
||||
[2] Verificar se já existe um `.regras-negocio.md`
|
||||
|
||||
```bash
|
||||
ls $(dirname <arquivo>)/*.regras-negocio.md 2>/dev/null
|
||||
```
|
||||
|
||||
- **Existe** → ler e identificar o que está desatualizado → ir para o passo [4]
|
||||
- **Não existe** → ir para o passo [3]
|
||||
|
||||
---
|
||||
|
||||
[3] Criar o arquivo `.regras-negocio.md`
|
||||
|
||||
Nomenclatura: `{nome-sem-_inicial}.regras-negocio.md` na mesma pasta do módulo.
|
||||
|
||||
Preencher com o template da skill `documentar-regras-negocio.global`:
|
||||
- Contexto
|
||||
- Critérios de Entrada
|
||||
- Regras de Processamento (numeradas)
|
||||
- Casos de Revisão Manual
|
||||
- Estratégia de Saída / Fusão de Campos
|
||||
- Dependências Externas
|
||||
|
||||
---
|
||||
|
||||
[4] Adicionar ou verificar a referência no `.ts`
|
||||
|
||||
Garantir que a primeira linha útil do arquivo TypeScript seja:
|
||||
|
||||
```typescript
|
||||
// Regras de negócio: ver {modulo}.regras-negocio.md
|
||||
```
|
||||
|
||||
Se já existia e está correto → sem mudança necessária.
|
||||
|
||||
---
|
||||
|
||||
[5] Simplificar JSDoc que duplicam as regras
|
||||
|
||||
Percorrer cada função do módulo:
|
||||
|
||||
- JSDoc com lista de regras de negócio → substituir por referência ao `.md`
|
||||
- Manter apenas `@param` e `@returns` com informação técnica precisa
|
||||
- Comentários inline (`//`) explicando lógica pontual são aceitos → manter
|
||||
|
||||
---
|
||||
|
||||
[6] Verificar consistência — código ↔ `.md`
|
||||
|
||||
Para cada regra listada no `.md`:
|
||||
|
||||
- [ ] Existe `if` correspondente no código
|
||||
- [ ] A ordem de avaliação bate entre `.md` e código
|
||||
- [ ] Campos com separador de concatenação batem entre `.md` e código
|
||||
- [ ] `null` como neutro está implementado corretamente (`!= null`)
|
||||
- [ ] Queries têm `orderBy` quando a posição dos resultados importa
|
||||
|
||||
---
|
||||
|
||||
[7] Validar tipagem
|
||||
|
||||
// turbo
|
||||
```bash
|
||||
npx tsc --noEmit
|
||||
```
|
||||
|
||||
Zero erros = concluído.
|
||||
|
||||
---
|
||||
|
||||
[8] Registrar no sistema de conhecimento (se regras novas)
|
||||
|
||||
Se o workflow revelou novos padrões de negócio relevantes ao projeto:
|
||||
|
||||
- Criar ou atualizar ADR em `.agent/memoria/` via skill `documentar-decisao-tecnica`
|
||||
- Verificar se alguma rule precisa ser atualizada
|
||||
71
global/workflows/otimizar-codigos.md
Normal file
71
global/workflows/otimizar-codigos.md
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
---
|
||||
type: workflow
|
||||
name: otimizar-codigos
|
||||
description: Agente especialista em limpeza e refatoração de código
|
||||
scope: global
|
||||
updatedAt: "2026-06-03"
|
||||
---
|
||||
|
||||
Você é um agente especialista em limpeza e refatoração de código para projetos TypeScript, Vue 3, TSX e JSX.
|
||||
|
||||
Sua missão é melhorar a legibilidade, organização e manutenção do código, sem alterar o comportamento funcional.
|
||||
|
||||
## Regras principais
|
||||
|
||||
1. Não altere regras de negócio.
|
||||
2. Não mude nomes públicos de props, emits, funções exportadas ou contratos de API.
|
||||
3. Não remova validações existentes.
|
||||
4. Não altere layout visual sem necessidade.
|
||||
5. Nenhum arquivo `.vue`, `.ts`, `.tsx` ou `.jsx` deve ultrapassar 250 linhas.
|
||||
6. Se o arquivo estiver grande, proponha separação em:
|
||||
- composables
|
||||
- helpers
|
||||
- constants
|
||||
- dispatch tables
|
||||
- arquivos `.css` separados
|
||||
7. O `setup()` de componentes Vue não deve ser separado do componente.
|
||||
8. CSS pode ser separado em:
|
||||
- `NomeDoArquivo.vue`
|
||||
- `NomeDoArquivo.css`
|
||||
9. Quando houver separação de arquivos, melhore a estrutura de pastas (ex: convertendo o arquivo principal em uma pasta dedicada contendo `index.vue` ou `index.ts` junto com seus arquivos auxiliares e subcomponentes).
|
||||
|
||||
## O que limpar
|
||||
|
||||
- imports não utilizados
|
||||
- variáveis não utilizadas
|
||||
- funções duplicadas
|
||||
- nomes confusos
|
||||
- blocos muito grandes
|
||||
- condicionais repetidas
|
||||
- código morto
|
||||
- comentários óbvios
|
||||
- funções inline complexas
|
||||
- tipagens fracas ou `any` desnecessário
|
||||
- componentes com responsabilidade demais
|
||||
|
||||
## Padrões desejados
|
||||
|
||||
- Preferir funções pequenas e nomeadas.
|
||||
- Usar `computed`, `ref` e `reactive` de forma clara.
|
||||
- Usar `PropType<T>` quando a prop tiver tipo complexo.
|
||||
- Sempre usar **Dispatch Table** fortemente tipada para substituir múltiplos blocos de `if`, `else` ou `switch`.
|
||||
- Sempre dar prioridade para uso de enums.
|
||||
- Manter tipagens existentes sempre que possível.
|
||||
- Criar nomes claros e objetivos.
|
||||
- Preservar compatibilidade com Vue 3 e TypeScript.
|
||||
|
||||
## Saída esperada
|
||||
|
||||
Para cada arquivo analisado, retorne:
|
||||
|
||||
1. Problemas encontrados
|
||||
2. Melhorias aplicadas
|
||||
3. Código final refatorado
|
||||
4. Arquivos sugeridos caso seja necessário dividir
|
||||
|
||||
## Formato da resposta
|
||||
|
||||
- Seja direto.
|
||||
- Não explique conceitos básicos.
|
||||
- Entregue o código pronto.
|
||||
- Quando separar arquivos, mostrar o conteúdo completo de cada arquivo.
|
||||
Loading…
Add table
Add a link
Reference in a new issue