@dewtech/dare-cli 0.3.5 → 0.3.8

package/templates/ide/antigravity/.agents/skills/dare-tasks/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: dare-tasks
+description: Gera Task Groups estruturados a partir do Blueprint aprovado. Use quando o usuário aprovar o BLUEPRINT.md. Cria um documento TASKS.md com tarefas atômicas e especificações isoladas para cada uma.
+---
+
+# DARE Tasks Skill
+
+Você é um especialista em decomposição de projetos e planejamento de tarefas. Seu objetivo é quebrar o Blueprint em tarefas atômicas, executáveis e testáveis.
+
+## Quando usar esta skill
+
+- Blueprint.md foi aprovado pelo usuário
+- Precisa-se quebrar a arquitetura em tarefas
+- Necessário criar especificações isoladas
+- Terceira fase do Método DARE
+
+## Como usar
+
+### Passo 1: Ler o Blueprint Aprovado
+Leia o arquivo `DARE/BLUEPRINT.md` que foi aprovado. Extraia:
+- Fases do plano de execução
+- Endpoints a implementar
+- Modelos de dados
+- Estrutura de diretórios
+
+### Passo 2: Quebrar em Tarefas Atômicas
+Cada tarefa deve:
+- Ser pequena o suficiente para uma conversa
+- Ter dependências claras
+- Ser testável isoladamente
+- Incluir validações de segurança
+
+### Passo 3: Integrar Segurança
+Para cada tarefa, inclua:
+- Validações de entrada
+- Autenticação/Autorização
+- Testes de segurança
+- Proteção contra vulnerabilidades
+
+### Passo 4: Gerar TASKS.md
+Crie um documento `DARE/TASKS.md` com visão geral:
+
+```markdown
+# Tasks: [Nome do Projeto]
+
+## Visão Geral
+Total de Tasks: [N]
+Fases: [Número]
+Tempo Estimado: [Tempo]
+
+## Dependências
+
+```
+Phase 1: Setup
+  └─ Task 001: Migrations
+  └─ Task 002: JWT Setup
+
+Phase 2: Auth
+  ├─ Task 003: RegisterController (depende de Task 001)
+  ├─ Task 004: LoginController (depende de Task 001)
+  └─ Task 005: RefreshController (depende de Task 001)
+
+Phase 3: Protection
+  ├─ Task 006: JWT Middleware (depende de Task 002)
+  ├─ Task 007: Rate Limiting (depende de Task 006)
+  └─ Task 008: Logout (depende de Task 006)
+
+Phase 4: Testing
+  ├─ Task 009: Unit Tests (depende de Task 003-008)
+  ├─ Task 010: Integration Tests (depende de Task 009)
+  └─ Task 011: Docker Setup (depende de Task 010)
+```
+
+## Tarefas por Fase
+
+### Phase 1: Setup Inicial
+
+#### Task 001: Criar Migrations de Users
+- Arquivo: `DARE/EXECUTION/task-001.md`
+- Tempo: 15 min
+- Dependências: Nenhuma
+
+#### Task 002: Configurar JWT
+- Arquivo: `DARE/EXECUTION/task-002.md`
+- Tempo: 20 min
+- Dependências: Nenhuma
+
+### Phase 2: Autenticação
+
+#### Task 003: Implementar RegisterController
+- Arquivo: `DARE/EXECUTION/task-003.md`
+- Tempo: 30 min
+- Dependências: Task 001
+
+#### Task 004: Implementar LoginController
+- Arquivo: `DARE/EXECUTION/task-004.md`
+- Tempo: 30 min
+- Dependências: Task 001, Task 002
+
+#### Task 005: Implementar RefreshController
+- Arquivo: `DARE/EXECUTION/task-005.md`
+- Tempo: 25 min
+- Dependências: Task 001, Task 002
+
+### Phase 3: Proteção
+
+#### Task 006: Implementar JWT Middleware
+- Arquivo: `DARE/EXECUTION/task-006.md`
+- Tempo: 20 min
+- Dependências: Task 002
+
+#### Task 007: Implementar Rate Limiting
+- Arquivo: `DARE/EXECUTION/task-007.md`
+- Tempo: 25 min
+- Dependências: Task 006
+
+#### Task 008: Implementar Logout
+- Arquivo: `DARE/EXECUTION/task-008.md`
+- Tempo: 20 min
+- Dependências: Task 006
+
+### Phase 4: Testing
+
+#### Task 009: Testes Unitários
+- Arquivo: `DARE/EXECUTION/task-009.md`
+- Tempo: 40 min
+- Dependências: Task 003-008
+
+#### Task 010: Testes de Integração
+- Arquivo: `DARE/EXECUTION/task-010.md`
+- Tempo: 50 min
+- Dependências: Task 009
+
+#### Task 011: Docker Setup
+- Arquivo: `DARE/EXECUTION/task-011.md`
+- Tempo: 30 min
+- Dependências: Task 010
+
+## Próximas Etapas
+1. Revisar e aprovar este TASKS.md
+2. Executar `/execute-task task-001` para começar
+3. Continuar com o Método DARE
+```
+
+### Passo 5: Gerar Especificações Isoladas
+Para CADA tarefa, crie um arquivo `DARE/EXECUTION/task-[id].md`:
+
+```markdown
+# Task 001: Criar Migrations de Users
+
+## Objetivo
+Criar as migrations para tabelas de users e refresh_tokens.
+
+## Descrição
+Implementar duas migrations Laravel:
+1. create_users_table.php
+2. create_refresh_tokens_table.php
+
+## Especificações
+
+### Tabela: users
+- id: UUID (PK)
+- email: VARCHAR(255) UNIQUE NOT NULL
+- password_hash: VARCHAR(255) NOT NULL
+- name: VARCHAR(255) NOT NULL
+- is_active: BOOLEAN DEFAULT true
+- created_at: TIMESTAMP
+- updated_at: TIMESTAMP
+
+### Tabela: refresh_tokens
+- id: UUID (PK)
+- user_id: UUID (FK → users.id)
+- token: VARCHAR(500) UNIQUE
+- expires_at: TIMESTAMP NOT NULL
+- revoked_at: TIMESTAMP NULL
+- created_at: TIMESTAMP
+
+## Arquivos a Criar
+- `database/migrations/YYYY_MM_DD_HHMMSS_create_users_table.php`
+- `database/migrations/YYYY_MM_DD_HHMMSS_create_refresh_tokens_table.php`
+
+## Validações (Validation Gates)
+- [ ] Migrations criadas sem erros
+- [ ] Tabelas têm índices apropriados
+- [ ] Foreign keys estão corretas
+- [ ] Timestamps são automáticos
+- [ ] `php artisan migrate` executa sem erros
+
+## Testes
+```bash
+php artisan migrate
+php artisan migrate:rollback
+php artisan migrate
+```
+
+## Segurança
+- Senhas nunca são armazenadas em texto plano
+- Tokens têm expiração
+- Soft deletes para dados históricos
+
+## Próxima Task
+Task 002: Configurar JWT
+
+## Notas
+- Use UUID em vez de auto-increment
+- Considere índices em email e user_id
+```
+
+### Passo 6: Pedir Aprovação
+Após gerar todas as tasks:
+- Peça ao usuário revisar
+- Confirme dependências
+- Aprove antes de executar
+
+## Boas Práticas
+
+1. **Atômicas:** Cada task é independente
+2. **Testáveis:** Inclua validation gates
+3. **Documentadas:** Especificações claras
+4. **Seguras:** Integre requisitos OWASP
+5. **Sequenciadas:** Respeite dependências
+
+## Dicas para Melhor Resultado
+
+- **Tamanho:** Tasks devem levar 15-60 minutos
+- **Testes:** Sempre inclua validation gates
+- **Segurança:** Consulte `skill-security` para cada task
+- **Exemplos:** Use `examples/` como referência
+- **Templates:** Use `templates/TASK-SPEC-template.md`

package/templates/ide/antigravity/templates/BLUEPRINT-template.md

@@ -0,0 +1,53 @@
+# BLUEPRINT DE IMPLEMENTAÇÃO: [Nome do Projeto]
+
+## 1. VISÃO GERAL DA ARQUITETURA
+[Descrição da arquitetura do sistema: Monolito modular, Microserviços, Hexagonal, etc.]
+[Diagrama em formato Mermaid se aplicável]
+
+## 2. STACK TÉCNICA DEFINIDA
+- **Linguagem:** [ex: PHP 8.3]
+- **Framework:** [ex: Laravel 11.x]
+- **Banco de Dados:** [ex: PostgreSQL 16.x]
+- **Pacotes Essenciais:** [Lista de dependências do composer/npm]
+
+## 3. MODELO DE DADOS
+[Entidades principais, relacionamentos e tipos de dados]
+[Exemplo de Migration Laravel ou Model Pydantic/Go Struct]
+
+## 4. ESTRUTURA DE PASTAS E ARQUIVOS
+[Árvore de diretórios completa focando nos arquivos que serão criados/modificados]
+```text
+app/
+├── Http/
+│   ├── Controllers/
+│   └── Requests/
+├── Models/
+├── Services/
+└── ...
+```
+
+## 5. ENDPOINTS DA API
+| Método | Endpoint | Controller@Method | Descrição | Request Body | Response | Auth |
+|---|---|---|---|---|---|---|
+| POST | /api/v1/users | UserController@store | Cria usuário | {name, email, pass} | {id, token} | Não |
+| GET | /api/v1/users | UserController@index | Lista usuários | - | [{id, name}] | Sim |
+
+## 6. CÓDIGO-BASE / PADRÕES A SEGUIR
+[Trechos de código críticos que definem o padrão do projeto]
+[Exemplo: Interface de repositório, FormRequest base, Trait de respostas de API]
+
+## 7. PLANO DE EXECUÇÃO (FASES)
+- **Fase 1:** Setup do projeto e Banco de Dados (Migrations/Seeds)
+- **Fase 2:** Autenticação e Autorização (Middlewares/Policies)
+- **Fase 3:** [Módulo Principal 1]
+- **Fase 4:** [Módulo Principal 2]
+- **Fase N:** Testes e Documentação
+
+## 8. COMANDOS DE SETUP
+[Todos os comandos para rodar o projeto do zero, ex: docker-compose up, php artisan migrate, etc]
+
+## 9. CRITÉRIOS DE SUCESSO GERAIS
+- [ ] O código passa em todos os testes (`php artisan test`)
+- [ ] Não há erros de linting (`./vendor/bin/pint`)
+- [ ] A API responde conforme os endpoints definidos
+- [ ] A documentação Swagger/OpenAPI está atualizada

package/templates/ide/antigravity/templates/DESIGN-template.md

@@ -0,0 +1,34 @@
+# PROJETO: [Nome do Projeto]
+
+## DESCRIÇÃO
+[O que é o sistema em 2-3 frases claras e objetivas]
+
+## FUNCIONALIDADES
+- [Funcionalidade 1: descrição detalhada]
+- [Funcionalidade 2: descrição detalhada]
+- [...]
+
+## STACK TÉCNICA
+- **Linguagem:** [ex: PHP 8.3]
+- **Framework:** [ex: Laravel 11]
+- **Banco de Dados:** [ex: PostgreSQL 16]
+- **Frontend:** [ex: Vue.js 3 / Nuxt]
+- **Outros:** [ex: Redis, S3]
+
+## REQUISITOS TÉCNICOS E DE NEGÓCIO
+- [Requisito 1: ex. API deve responder em menos de 200ms]
+- [Requisito 2: ex. Autenticação via JWT (Sanctum)]
+- [Requisito 3: ex. Cobertura de testes unitários > 80%]
+
+## INTEGRAÇÕES
+- [Integração 1: ex. Stripe para pagamentos (link da doc)]
+- [Integração 2: ex. AWS S3 para armazenamento de arquivos]
+
+## RESTRIÇÕES
+- **Prazo:** [Data limite ou restrição de tempo]
+- **Orçamento:** [Limitações de custo com infra/APIs]
+- **Limitações Técnicas:** [ex. Não pode usar banco NoSQL]
+
+## FORA DO ESCOPO
+- [O que NÃO será feito nesta versão]
+- [Funcionalidades adiadas para v2]

package/templates/ide/antigravity/templates/TASK-SPEC-template.md

@@ -0,0 +1,43 @@
+# ESPECIFICAÇÃO DE TAREFA: [ID da Task, ex: task-001]
+
+## OBJETIVO DA TAREFA
+[Descrição concisa do que precisa ser implementado, ex: Criar o Model, Migration e Factory para a entidade Usuário.]
+
+## CONTEXTO E DEPENDÊNCIAS
+- **Fase:** [Nome da Fase]
+- **Depende de:** [ID de tasks anteriores, ex: Nenhuma / task-000]
+- **Arquivos Relacionados Existentes:** [Arquivos que servem de base ou serão modificados, ex: `app/Models/User.php`]
+
+## ESPECIFICAÇÃO DE IMPLEMENTAÇÃO (O QUE FAZER)
+[Instruções detalhadas passo a passo para a IA Executora]
+
+1. **[Passo 1, ex: Atualizar a migration `create_users_table`]**
+   - Adicionar coluna `role` (enum: admin, user).
+   - Adicionar coluna `is_active` (boolean, default true).
+
+2. **[Passo 2, ex: Atualizar o Model `User`]**
+   - Adicionar campos ao `$fillable`.
+   - Criar os casts corretos.
+
+3. **[Passo 3, ex: Criar/Atualizar a Factory]**
+   - Garantir que os novos campos sejam gerados pelo Faker.
+
+## EXEMPLOS E PADRÕES A SEGUIR
+- **Referência:** Siga o padrão de formatação definido em `.cursorrules`.
+- **Exemplo Existente:** Se houver um model parecido, cite aqui (ex: `app/Models/Product.php`).
+
+## CRITÉRIOS DE SUCESSO (VALIDATION GATES)
+Estes comandos DEVEM ser executados pela IA para validar a implementação antes de concluir a tarefa.
+
+```bash
+# 1. Linting / Formatação
+./vendor/bin/pint
+
+# 2. Análise Estática (se aplicável, ex: PHPStan/Larastan)
+./vendor/bin/phpstan analyse
+
+# 3. Testes Unitários/Feature
+php artisan test --filter=UserTest
+```
+
+Se algum comando falhar, a IA deve ler o erro, consertar o código e rodar o comando novamente (Ralph Loop) até que todos os testes passem.

package/templates/ide/antigravity/templates/TASKS-template.md

@@ -0,0 +1,26 @@
+# TASKS DE IMPLEMENTAÇÃO: [Nome do Projeto]
+
+Este documento contém o desdobramento do Blueprint aprovado em tarefas atômicas e executáveis para a IA.
+Cada tarefa listada aqui possui um arquivo correspondente no diretório `DARE/EXECUTION/` contendo sua especificação detalhada.
+
+## FASES DE IMPLEMENTAÇÃO
+
+### Fase 1: [Nome da Fase, ex: Setup e Banco de Dados]
+- [ ] **Task 001:** [Objetivo curto, ex: Criar Migration e Model de Usuário]
+- [ ] **Task 002:** [Objetivo curto, ex: Configurar Traits e Classes Base]
+
+### Fase 2: [Nome da Fase, ex: Autenticação]
+- [ ] **Task 003:** [Objetivo curto, ex: Implementar AuthController (Login/Register)]
+- [ ] **Task 004:** [Objetivo curto, ex: Criar Middlewares de verificação de permissão]
+
+## DEPENDÊNCIAS
+
+- A **Fase 2** depende da conclusão 100% da **Fase 1**.
+- A **Task 004** depende da **Task 003**.
+
+## INSTRUÇÕES PARA EXECUÇÃO
+
+Para executar uma tarefa, use o comando `/execute-task [id-da-task]` no Cursor Composer.
+Exemplo: `/execute-task task-001`
+
+A IA lerá o arquivo `DARE/EXECUTION/task-001.md`, implementará o código, rodará os testes e validará os critérios de sucesso. Após a execução, marque a tarefa como concluída (com um `x` entre os colchetes `[x]`) neste documento.

package/templates/ide/antigravity/templates/TELEMETRY-template.md

@@ -0,0 +1,125 @@
+# Telemetria do Projeto: [Nome do Projeto]
+
+## Resumo Executivo
+
+| Métrica | Valor |
+|---------|-------|
+| **Projeto** | [Nome do Projeto] |
+| **Data de Início** | [Data] |
+| **Tokens Totais Processados** | [Número] (monitoramento de uso) |
+| **IA Utilizada** | Cursor (por compliance) |
+| **Modelos do Cursor Utilizados** | [Lista: GPT-4 Turbo, Claude, Gemini] |
+| **Tempo Total de Execução** | [Horas/Minutos] |
+| **Número de Tasks Executadas** | [Número] |
+
+## Detalhamento por Etapa
+
+### 1. Design (`/generate-design`)
+
+| Campo | Valor |
+|-------|-------|
+| Data/Hora | [Timestamp] |
+| Modelo do Cursor | [GPT-4 Turbo / Claude 3.5 Sonnet / Gemini 2.0 Flash] |
+| Tokens Estimados | [Número] |
+| Tempo de Execução | [Tempo] |
+| Comando Executado | `/generate-design "[Descrição]"` |
+| Observações | [Qualidade da resposta, ajustes necessários, etc] |
+| Status | ✓ Sucesso / ✗ Falha |
+
+### 2. Blueprint (`/generate-blueprint`)
+
+| Campo | Valor |
+|-------|-------|
+| Data/Hora | [Timestamp] |
+| Modelo do Cursor | [GPT-4 Turbo / Claude 3.5 Sonnet / Gemini 2.0 Flash] |
+| Tokens Estimados | [Número] |
+| Tempo de Execução | [Tempo] |
+| Arquivo Processado | DARE/DESIGN.md |
+| Observações | [Qualidade da arquitetura, endpoints claros, etc] |
+| Status | ✓ Sucesso / ✗ Falha |
+
+### 3. Tasks (`/generate-tasks`)
+
+| Campo | Valor |
+|-------|-------|
+| Data/Hora | [Timestamp] |
+| Modelo do Cursor | [GPT-4 Turbo / Claude 3.5 Sonnet / Gemini 2.0 Flash] |
+| Tokens Estimados | [Número] |
+| Tempo de Execução | [Tempo] |
+| Arquivo Processado | DARE/BLUEPRINT.md |
+| Tasks Geradas | [Número] |
+| Observações | [Qualidade das tasks, clareza das especificações, etc] |
+| Status | ✓ Sucesso / ✗ Falha |
+
+### 4. Execute Tasks (`/execute-task`)
+
+#### Task 001: [Nome da Task]
+
+| Campo | Valor |
+|-------|-------|
+| Data/Hora | [Timestamp] |
+| Modelo do Cursor | [GPT-4 Turbo / Claude 3.5 Sonnet / Gemini 2.0 Flash] |
+| Tokens Estimados | [Número] |
+| Tempo de Execução | [Tempo] |
+| Tentativas (Ralph Loop) | [Número] |
+| Observações | [Código limpo, testes, etc] |
+| Status | ✓ Sucesso / ✗ Falha |
+
+#### Task 002: [Nome da Task]
+[Repetir estrutura acima para cada task]
+
+## Análise de Tokens Processados
+
+| Etapa | Tokens Estimados | % do Total | Tempo Total |
+|-------|------------------|-----------|-------------|
+| Design | [Número] | [%] | [Tempo] |
+| Blueprint | [Número] | [%] | [Tempo] |
+| Tasks | [Número] | [%] | [Tempo] |
+| Execute (N tasks) | [Número] | [%] | [Tempo] |
+| **TOTAL** | **[Número]** | **100%** | **[Tempo]** |
+
+## Análise de Modelos do Cursor
+
+| Modelo | Tokens Processados | % do Total | Tempo Médio | Melhor Para |
+|--------|------------------|-----------|------------|------------|
+| GPT-4 Turbo | [Número] | [%] | [Tempo] | Tarefas complexas |
+| Claude 3.5 Sonnet | [Número] | [%] | [Tempo] | Análise profunda |
+| Gemini 2.0 Flash | [Número] | [%] | [Tempo] | Tarefas simples |
+| **TOTAL** | **[Número]** | **100%** | **[Tempo]** | - |
+
+## Análise de Performance
+
+| Métrica | Valor |
+|---------|-------|
+| Tempo Médio por Task | [Tempo] |
+| Taxa de Sucesso (1ª tentativa) | [%] |
+| Taxa de Sucesso (com Ralph Loop) | [%] |
+| Tokens Médios por Task | [Número] |
+| Modelo Mais Utilizado | [Modelo] |
+| Modelo Mais Rápido | [Modelo] |
+
+## Otimizações Recomendadas
+
+1. **[Recomendação 1]**
+   - Descrição: [Detalhes]
+   - Economia Estimada: [Valor/Percentual]
+   - Ação: [Como implementar]
+
+2. **[Recomendação 2]**
+   - Descrição: [Detalhes]
+   - Economia Estimada: [Valor/Percentual]
+   - Ação: [Como implementar]
+
+3. **[Recomendação 3]**
+   - Descrição: [Detalhes]
+   - Economia Estimada: [Valor/Percentual]
+   - Ação: [Como implementar]
+
+## Notas e Observações
+
+[Espaço para anotações adicionais, como problemas encontrados, decisões tomadas, lições aprendidas, etc.]
+
+---
+
+**Última atualização:** [Data]
+**Próxima revisão:** [Data]

package/templates/ide/cursor/.cursor/commands/execute-task.md

@@ -0,0 +1,19 @@
+# Comando: /execute-task
+
+## Descrição
+Este comando finaliza o Método DARE (Execute) implementando o código e validando os testes de uma tarefa específica isolada.
+
+## Instruções para o Cursor Composer
+
+1. **Identifique a Tarefa:** Leia o `$ARGUMENTS` (ID da tarefa ou caminho do arquivo, ex: `task-001` ou `DARE/EXECUTION/task-001.md`).
+2. **Leia a Especificação da Tarefa:** Abra e leia a especificação detalhada da tarefa em `DARE/EXECUTION/[id].md`.
+3. **Analise o Contexto Global:** Leia o arquivo `.cursorrules` (ou equivalente) e a arquitetura geral em `DARE/BLUEPRINT.md` para garantir que o código será gerado dentro dos padrões do projeto.
+4. **Implemente o Código:**
+   - Execute passo a passo as instruções da seção "ESPECIFICAÇÃO DE IMPLEMENTAÇÃO".
+   - Crie ou modifique os arquivos necessários.
+   - Siga rigorosamente os padrões de código, tratamento de erros e convenções definidos nas regras globais e exemplos fornecidos.
+5. **O Loop de Validação (Ralph Loop):**
+   - Após a implementação, execute OBRIGATORIAMENTE os comandos definidos na seção "CRITÉRIOS DE SUCESSO (VALIDATION GATES)".
+   - Exemplo: `php artisan test --filter=NomeDoTeste` ou `./vendor/bin/pint`.
+   - Se algum comando falhar, LEIA O ERRO, CORRIJA O CÓDIGO e RODE O COMANDO NOVAMENTE até que todos passem com sucesso.
+6. **Mensagem Final:** Após o sucesso dos testes, atualize o status da tarefa no arquivo `DARE/TASKS.md` (marque com um `[x]`) e informe ao usuário: "Tarefa [ID] implementada e validada com sucesso. Os testes passaram."

package/templates/ide/cursor/.cursor/commands/generate-blueprint.md

@@ -0,0 +1,21 @@
+# Comando: /generate-blueprint
+
+## Descrição
+Este comando avança o Método DARE para a fase Architect, lendo o Design aprovado e gerando a arquitetura completa de implementação.
+
+## Instruções para o Cursor Composer
+
+1. **Leia o Documento Design:** Acesse e leia o arquivo `$ARGUMENTS` (geralmente `DARE/DESIGN.md`) que contém os requisitos do projeto.
+2. **Leia o Template:** Utilize a estrutura definida em `templates/BLUEPRINT-template.md`.
+3. **Analise o Contexto Global:** Leia o arquivo `.cursorrules` (ou equivalente) para entender as regras, convenções de nomenclatura e padrões de arquitetura exigidos pela stack do projeto.
+4. **Analise Exemplos:** Se houver arquivos na pasta `examples/`, analise-os para extrair os padrões de código esperados e incluí-los na seção "CÓDIGO-BASE / PADRÕES A SEGUIR".
+5. **Gere a Arquitetura (O Blueprint):**
+   - **Visão Geral:** Defina a arquitetura apropriada para o projeto (Monolito, Microserviços, Hexagonal, MVC).
+   - **Segurança (OWASP):** Adicione uma subseção explicando como as diretrizes da `skill-security.mdc` serão implementadas (ex: Bcrypt para senhas, Middlewares de Rate Limit, Validação estrita).
+   - **Modelo de Dados:** Projete o esquema completo do banco de dados (tabelas, campos, tipos, relacionamentos) e apresente em formato Markdown ou SQL simplificado. Certifique-se de que dados sensíveis estão protegidos.
+   - **Endpoints:** Liste todas as rotas da API necessárias com Request e Response esperados em uma tabela Markdown, incluindo as necessidades de Autenticação/Autorização.
+   - **Estrutura:** Esboce a árvore de diretórios dos arquivos que serão criados.
+   - **Plano de Execução:** Divida o projeto em Fases lógicas e sequenciais. A Fase 2 geralmente deve incluir o Setup de Segurança (Auth, Middlewares).
+   - **Comandos:** Liste comandos de setup (ex: migrations, composer install).
+6. **Salve o Arquivo:** Crie o arquivo `DARE/BLUEPRINT.md` com o conteúdo gerado.
+7. **Mensagem Final:** Informe ao usuário: "Documento BLUEPRINT.md gerado com sucesso. Por favor, revise a arquitetura e os endpoints. Quando estiver aprovado, execute `/generate-tasks DARE/BLUEPRINT.md`."

package/templates/ide/cursor/.cursor/commands/generate-bugfix-design.md

@@ -0,0 +1,64 @@
+---
+description: Analisa o projeto existente e gera um Design DARE focado na resolucao de um bug. Use quando precisar investigar e corrigir um erro complexo no sistema atual.
+globs: *
+---
+
+# Generate Bugfix Design
+
+## Objetivo
+Analisar a base de código atual, diagnosticar um problema relatado e gerar um documento de Design (`DARE/DESIGN-Bugfix-[Nome].md`) focado especificamente na **correção do bug**, mapeando a causa raiz e o plano de ação cirúrgico.
+
+## Contexto
+Este comando é para **projetos legados** ou em andamento onde um erro foi encontrado. O foco aqui é **diagnóstico e correção**: encontrar a causa raiz, analisar impacto e planejar a correção mais segura possível.
+
+## Passos que a IA deve seguir:
+
+1. **Análise de Contexto:**
+   - Entender o comportamento atual (o bug) vs o comportamento esperado
+   - Analisar logs, stack traces ou descrições de erro fornecidas
+   - Identificar a área do código responsável pelo problema
+
+2. **Diagnóstico da Causa Raiz:**
+   - Por que o erro está ocorrendo?
+   - É um problema de lógica, banco de dados, concorrência ou segurança?
+
+3. **Geração do Documento:**
+   - Criar o arquivo `DARE/DESIGN-Bugfix-[Nome-do-Bug].md`
+
+## Estrutura do Documento Gerado:
+
+```markdown
+# Bugfix Design: [Nome do Bug]
+
+## Descrição do Problema
+- **Comportamento Atual:** [O que está acontecendo de errado]
+- **Comportamento Esperado:** [O que deveria acontecer]
+- **Passos para Reproduzir:** [Se conhecido]
+
+## Diagnóstico da Causa Raiz
+Explicação técnica detalhada de por que o erro ocorre. (Ex: "A query N+1 está estourando a memória", ou "A validação não verifica campos nulos").
+
+## Análise de Impacto (Onde corrigir)
+- **Arquivos a Modificar:** [Lista de arquivos específicos]
+- **Banco de Dados:** [Necessário rodar script de correção de dados?]
+- **Riscos da Correção:** [O que pode quebrar ao consertar isso?]
+
+## Plano de Ação (Correção Cirúrgica)
+1. [Passo 1: Ajustar a query no Repository]
+2. [Passo 2: Adicionar teste unitário para cobrir o caso]
+3. [Passo 3: Validar comportamento]
+
+## Testes Necessários
+- **Validation Gates:** [O que testar para garantir que o bug sumiu]
+- **Testes de Regressão:** [O que testar para garantir que não quebrou o resto]
+
+## Próximas Etapas
+1. Revisar e aprovar este Bugfix Design
+2. Executar `/generate-blueprint DARE/DESIGN-Bugfix-[Nome].md` (opcional, se a correção for grande)
+3. Ou ir direto para `/generate-tasks DARE/DESIGN-Bugfix-[Nome].md`
+```
+
+## Regras de Ouro:
+- **Seja Cirúrgico:** A correção deve ser o menor código possível para resolver o problema sem efeitos colaterais.
+- **Causa Raiz:** Não trate apenas o sintoma, identifique e corrija a causa raiz.
+- **Evite Regressão:** Sempre mapeie os riscos da correção.

package/templates/ide/cursor/.cursor/commands/generate-design.md

@@ -0,0 +1,18 @@
+# Comando: /generate-design
+
+## Descrição
+Este comando inicia o Método DARE (Design) gerando um documento de requisitos a partir de uma ideia inicial.
+
+## Instruções para o Cursor Composer
+
+1. **Leia a Ideia Inicial:** Analise o prompt fornecido pelo usuário (`$ARGUMENTS`) que descreve o que ele deseja construir.
+2. **Leia o Template:** Utilize a estrutura definida em `templates/DESIGN-template.md`.
+3. **Analise o Contexto Global:** Leia o arquivo `.cursorrules` (ou equivalente na pasta `.cursor/rules/`) para entender a stack técnica do projeto e preencher automaticamente a seção de STACK TÉCNICA.
+4. **Gere o Documento:**
+   - Preencha o template com as informações extraídas do prompt.
+   - Organize as funcionalidades de forma clara.
+   - Identifique possíveis requisitos técnicos implícitos e restrições.
+   - **Integre Requisitos de Segurança (OWASP):** Adicione obrigatoriamente requisitos de segurança na seção correspondente (ex: Rate Limiting, HTTPS, Proteção contra Força Bruta) baseando-se na skill `skill-security.mdc`.
+   - Defina claramente o que fica FORA DO ESCOPO para manter o foco da versão.
+5. **Salve o Arquivo:** Crie o arquivo `DARE/DESIGN.md` com o conteúdo gerado.
+6. **Mensagem Final:** Informe ao usuário: "Documento DESIGN.md gerado com sucesso. Por favor, revise e aprove o documento. Quando estiver pronto, execute `/generate-blueprint DARE/DESIGN.md`."

package/templates/ide/cursor/.cursor/commands/generate-docker-compose.md

@@ -0,0 +1,18 @@
+# Comando: /generate-docker-compose
+
+## Descrição
+Este comando analisa a arquitetura definida no BLUEPRINT.md e gera um `docker-compose.yml` completo com todos os serviços necessários (App, DB, Cache, etc).
+
+## Instruções para o Cursor Composer
+
+1. **Leia o Documento Blueprint:** Acesse o `DARE/BLUEPRINT.md` (se existir) para identificar as dependências do sistema (ex: PostgreSQL, Redis, Mailhog).
+2. **Leia o Contexto Global:** Leia o `.cursorrules` para confirmar as versões do banco de dados e outras ferramentas.
+3. **Leia a Skill Docker:** Leia `.cursor/rules/skill-docker.mdc` para aplicar boas práticas (Healthchecks, Redes, Volumes).
+4. **Gere o docker-compose.yml:**
+   - Crie um arquivo `docker-compose.yml` na raiz do projeto.
+   - **Serviço App:** Use o `build: .` (Dockerfile gerado). Exponha a porta correta. Defina variáveis de ambiente ou carregue do `.env`. Configure `depends_on` para DB/Cache.
+   - **Serviço Webserver (Laravel):** Se for Laravel, crie um serviço `nginx` dependente do `app` (PHP-FPM) e configure os volumes para compartilhar a pasta `/var/www/html`.
+   - **Serviço Banco de Dados:** Adicione o banco de dados (ex: `postgres:16-alpine` ou `mysql:8.0`). Defina variáveis de ambiente para usuário, senha e database (`POSTGRES_DB`, `POSTGRES_USER`). Adicione um `healthcheck` para testar a conexão (`pg_isready -U user`). Crie um volume nomeado para os dados (`db_data:/var/lib/postgresql/data`).
+   - **Serviço Cache (Opcional):** Se o projeto usar Redis, adicione o serviço `redis:7-alpine`.
+   - **Redes e Volumes:** Defina as redes customizadas (ex: `app-network`) e volumes (`db_data`, `redis_data`) no final do arquivo.
+5. **Mensagem Final:** Informe ao usuário: "Arquivo docker-compose.yml gerado com sucesso. Todos os serviços (App, [DB], [Cache]) foram configurados com healthchecks, volumes persistentes e redes isoladas. Revise as portas e variáveis de ambiente no .env antes de executar `docker-compose up -d`."

package/templates/ide/cursor/.cursor/commands/generate-dockerfile.md

@@ -0,0 +1,17 @@
+# Comando: /generate-dockerfile
+
+## Descrição
+Este comando analisa a stack do projeto (definida no DESIGN.md ou .cursorrules) e gera um `Dockerfile` otimizado para produção e desenvolvimento.
+
+## Instruções para o Cursor Composer
+
+1. **Analise o Contexto:** Leia o arquivo `.cursorrules` e o `DARE/DESIGN.md` (se existir) para identificar a stack tecnológica principal (Linguagem, Framework, Versões).
+2. **Leia a Skill Docker:** Leia as regras em `.cursor/rules/skill-docker.mdc` para aplicar as melhores práticas de containerização.
+3. **Gere o Dockerfile:**
+   - Crie um Dockerfile na raiz do projeto (`./Dockerfile`).
+   - **Para PHP/Laravel:** Use multi-stage build. Instale extensões necessárias (pdo_mysql/pgsql, mbstring, exif, pcntl, bcmath, gd). Configure o `www-data` e ajuste permissões de `/var/www/html/storage` e `bootstrap/cache`.
+   - **Para Python:** Use `python:slim`. Crie um usuário não-root. Copie `requirements.txt` primeiro, instale dependências e depois copie o código.
+   - **Para Go:** Use multi-stage. Estágio 1: `golang:alpine` para build (`go build -o app`). Estágio 2: `alpine` ou `scratch` rodando apenas o binário.
+   - **Para Node/Vue:** Estágio 1: `node:alpine` para build (`npm run build`). Estágio 2: `nginx:alpine` para servir a pasta `dist`.
+4. **Gere o .dockerignore:** Crie um arquivo `.dockerignore` na raiz do projeto ignorando pastas desnecessárias (`node_modules`, `vendor`, `.git`, `.env`, `tests`, `DARE`).
+5. **Mensagem Final:** Informe ao usuário: "Dockerfile e .dockerignore gerados com sucesso e otimizados para a stack [NOME_DA_STACK]. Revise os arquivos gerados. Para criar a orquestração de serviços, execute `/generate-docker-compose`."