@dewtech/dare-cli 2.17.0 → 3.1.0

package/templates/ide/cursor/.cursor/rules/skill-migrate.mdc

@@ -0,0 +1,58 @@
+---
+description: Camada semântica da migração (Fase 2 brownfield). Roda depois do comando `dare migrate` e escreve a estratégia de migração + cenários Gherkin de paridade reais no DARE/MIGRATION/, garantindo reimplementação fiel ao legado.
+globs: DARE/MIGRATION/**
+alwaysApply: false
+---
+
+# Skill: Migrate — Migração com paridade (brownfield Fase 2)
+
+Camada **semântica** da migração. Roda **depois** do comando `dare migrate`, que já leu os artefatos
+do `reverse`/`dna` e gerou os esqueletos. Sua função é **escrever a estratégia de migração e os
+cenários Gherkin de paridade reais** — o contrato comportamental que garante reimplementação fiel.
+
+> Pré-requisito: rodar `dare migrate --to <stack>` antes (gera `DARE/MIGRATION/MIGRATION.md`,
+> `migration-facts.json`, `parity/*.feature`). Que por sua vez exige `dare reverse` já feito.
+
+## Quando usar
+- Projeto legado entendido (`reverse` + `dna`) que será reimplementado em outra stack.
+- Acabou de rodar `dare migrate` e há seções `<!-- AGENT -->` / `# AGENT` em aberto.
+
+## O que fazer
+
+### 1. Carregar contexto (não re-varrer)
+Leia `migration-facts.json` (origem/alvo/módulos/blocking gaps), `IDEIA.md` + `REVERSE/module-*.md`
+e `PROJECT-DNA.md`. Abra arquivos-chave do legado só o necessário.
+
+### 2. Preencher `MIGRATION.md`
+- **Decisão de Paradigma** — mudou (procedural→OO, monólito→serviços)? Decisão + justificativa.
+- **Estratégia** — big-bang vs. strangler/parallel-run; ordem dos módulos; feature flags.
+- **Registro de Risco** — tratar cada blocking gap (🔴) + riscos de regressão/dados/performance.
+- **Arquitetura-alvo** — na stack-alvo, alinhada ao DNA quando o paradigma for preservado.
+- **Cutover & Rollback** — passos, validação de paridade (rodar `.feature`), go/no-go, rollback.
+
+### 3. Gherkin de paridade (`parity/<módulo>.feature`)
+Um `Scenario` por fluxo observável, derivado do **comportamento legado real**: `Given` → `When` →
+`Then` idêntico ao legado. Inclua bordas/formatos (arredondamento, máscaras). É o contrato de aceite.
+
+### 4. Apresentar ao usuário
+Resumo: paradigma, estratégia, nº de cenários, blocking gaps a resolver.
+
+## Regras de ouro
+1. **Paridade primeiro** — todo fluxo crítico vira `Scenario`.
+2. **Blocking gaps são bloqueantes** — 🔴 não resolvido é risco; trate ou registre.
+3. **Respeite o DNA** — arquitetura-alvo segue as convenções da casa.
+4. **Não invente comportamento** — cenário sem base no legado = regressão silenciosa.
+5. **Strangler quando possível** — incremental com parallel-run reduz risco.
+
+## Antipatterns
+| AP | Antipattern | Por quê |
+|---|---|---|
+| AP-01 | Gherkin genérico sem base no legado | Não garante paridade |
+| AP-02 | Ignorar blocking gaps (🔴) | Reimplementa sobre incerteza |
+| AP-03 | Big-bang sem necessidade | Maximiza risco |
+| AP-04 | Arquitetura-alvo desalinhada do DNA | Código vira ilha inconsistente |
+| AP-05 | Reescrever os fatos determinísticos do CLI | Quebra a fonte de verdade |
+
+---
+
+Skill MIT — parte do DARE Method. Fase 2 (brownfield). Pareia com o comando `dare migrate`.

package/templates/ide/cursor/.cursor/rules/skill-nestjs-api.mdc

@@ -0,0 +1,346 @@
+---
+description: Padrões DARE para APIs REST em NestJS + TypeScript + Prisma + Swagger. Modules, Controllers, Services, DTOs com class-validator, Guards JWT, throttler, exceções globais, Jest + Supertest, OpenAPI auto-gerado.
+globs: src/**/*.ts,src/**/*.controller.ts,src/**/*.service.ts,src/**/*.module.ts,prisma/schema.prisma
+alwaysApply: false
+---
+
+# Skill: NestJS API DARE
+
+Você é um desenvolvedor sênior TypeScript / NestJS focado em APIs REST. Esta skill garante código **idiomático Nest, fortemente tipado, com auth/autz robustos e OpenAPI auto-gerado**, seguindo Layered Design DARE.
+
+## Stack canônica
+
+- **TypeScript 5.5+** com `strict: true`
+- **NestJS 11.x**
+- **Prisma 5.x** ORM (PostgreSQL ou MySQL)
+- **class-validator + class-transformer**
+- **@nestjs/swagger**
+- **@nestjs/throttler**
+- **@nestjs/passport + @nestjs/jwt**
+- **Jest + Supertest**
+
+---
+
+## Estrutura de módulo (Layered Design)
+
+```
+src/<feature>/
+├── <feature>.module.ts          ← providers + controllers
+├── <feature>.controller.ts      ← Handler
+├── <feature>.service.ts         ← Service (1 operação ou facade)
+├── <feature>.repository.ts      ← Repository (Prisma)
+├── dto/
+│   ├── create-<feature>.dto.ts
+│   └── update-<feature>.dto.ts
+├── entities/
+│   └── <feature>.entity.ts      ← Model
+└── tests/
+    ├── <feature>.service.spec.ts
+    └── <feature>.e2e-spec.ts
+```
+
+---
+
+## Controllers (Handler)
+
+```typescript
+import { Body, Controller, Post, UseGuards } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiCreatedResponse } from '@nestjs/swagger';
+import { JwtAuthGuard } from '@/auth/jwt-auth.guard';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UserResponseDto } from './dto/user-response.dto';
+import { RegisterUserService } from './register-user.service';
+
+@ApiTags('users')
+@Controller('users')
+@UseGuards(JwtAuthGuard)
+export class UsersController {
+  constructor(private readonly register: RegisterUserService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Criar novo usuário' })
+  @ApiCreatedResponse({ type: UserResponseDto })
+  async create(@Body() dto: CreateUserDto): Promise<UserResponseDto> {
+    const user = await this.register.execute(dto);
+    return UserResponseDto.from(user);
+  }
+}
+```
+
+Regras:
+- Apenas: recebe → valida via DTO → chama Service → retorna ResponseDto
+- NUNCA: Prisma direto, lógica de negócio, validação inline
+
+---
+
+## DTOs com class-validator
+
+```typescript
+import { IsEmail, IsString, MinLength } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class CreateUserDto {
+  @ApiProperty({ example: 'jane@example.com' })
+  @IsEmail() email!: string;
+
+  @ApiProperty({ example: 'Jane Doe' })
+  @IsString() name!: string;
+
+  @ApiProperty({ minLength: 12 })
+  @IsString() @MinLength(12) password!: string;
+}
+```
+
+`main.ts` global pipe:
+```typescript
+app.useGlobalPipes(new ValidationPipe({
+  whitelist: true,
+  forbidNonWhitelisted: true,
+  transform: true,
+}));
+```
+
+---
+
+## Services
+
+Uma operação por classe:
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { hash } from '@node-rs/argon2';
+import { UsersRepository } from './users.repository';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UserAlreadyExistsError } from './errors';
+
+@Injectable()
+export class RegisterUserService {
+  constructor(private readonly repo: UsersRepository) {}
+
+  async execute(dto: CreateUserDto) {
+    if (await this.repo.existsByEmail(dto.email)) {
+      throw new UserAlreadyExistsError();
+    }
+    return this.repo.create({
+      ...dto,
+      password: await hash(dto.password),
+    });
+  }
+}
+```
+
+---
+
+## Repositories (Prisma)
+
+```typescript
+@Injectable()
+export class UsersRepository {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async existsByEmail(email: string): Promise<boolean> {
+    return !!(await this.prisma.user.findUnique({ where: { email } }));
+  }
+
+  async create(data: { email: string; name: string; password: string }) {
+    return this.prisma.user.create({ data });
+  }
+}
+```
+
+---
+
+## Tratamento global de exceções
+
+```typescript
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    const response = host.switchToHttp().getResponse<Response>();
+
+    if (exception instanceof UserAlreadyExistsError) {
+      return response.status(409).json({ error: 'USER_EXISTS' });
+    }
+    if (exception instanceof HttpException) {
+      return response.status(exception.getStatus()).json(exception.getResponse());
+    }
+    return response.status(500).json({ error: 'INTERNAL' });
+  }
+}
+
+// main.ts
+app.useGlobalFilters(new AllExceptionsFilter());
+```
+
+---
+
+## OpenAPI auto-gerado
+
+```typescript
+const config = new DocumentBuilder()
+  .setTitle('Projeto API')
+  .setVersion('1.0')
+  .addBearerAuth()
+  .build();
+
+const document = SwaggerModule.createDocument(app, config);
+SwaggerModule.setup('docs', app, document);          // UI em /docs
+writeFileSync('./public/openapi.json', JSON.stringify(document));
+```
+
+---
+
+## Rate limiting
+
+```typescript
+import { ThrottlerModule, Throttle } from '@nestjs/throttler';
+
+@Module({
+  imports: [
+    ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }]),
+  ],
+})
+export class AppModule {}
+
+// Endpoint sensível
+@Throttle({ default: { limit: 5, ttl: 900_000 } })  // 5/15min
+@Post('login')
+async login() {...}
+```
+
+---
+
+## Auth (JWT + Passport)
+
+```typescript
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(config: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      secretOrKey: config.getOrThrow('JWT_SECRET'),
+    });
+  }
+  async validate(payload: any) {
+    return { id: payload.sub, email: payload.email };
+  }
+}
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {}
+```
+
+---
+
+## Testes
+
+### Unit (service)
+
+```typescript
+describe('RegisterUserService', () => {
+  it('falha se email já existe', async () => {
+    const repo = { existsByEmail: jest.fn().mockResolvedValue(true) } as any;
+    const sut = new RegisterUserService(repo);
+    await expect(sut.execute({ email: 'x@y.com', name: 'X', password: 'longsecret123' }))
+      .rejects.toThrow(UserAlreadyExistsError);
+  });
+});
+```
+
+### E2E (Supertest)
+
+```typescript
+describe('POST /users', () => {
+  it('cria com sucesso', async () => {
+    const res = await request(app.getHttpServer())
+      .post('/users')
+      .set('Authorization', `Bearer ${adminToken}`)
+      .send({ email: 'jane@example.com', name: 'Jane', password: 'longsecret123' });
+    expect(res.status).toBe(201);
+    expect(res.body.email).toBe('jane@example.com');
+  });
+});
+```
+
+---
+
+## Antipatterns
+
+| AP | Antipattern | Correção |
+|---|---|---|
+| AP-01 | Validação inline | DTO + ValidationPipe |
+| AP-02 | Prisma no Controller | Repository |
+| AP-03 | Lógica no Controller | Service |
+| AP-04 | Sem DTO de saída | `UserResponseDto.from(user)` |
+| AP-05 | Secret hardcoded | `ConfigService.getOrThrow` |
+| AP-06 | Login sem throttler | rate limit obrigatório |
+| AP-07 | OpenAPI à mão | `@nestjs/swagger` |
+| AP-08 | Erros sem filter global | inconsistência de response |
+| AP-09 | `Prisma.user.findFirst` sem WHERE em tenant | A01 — Broken Access Control |
+
+---
+
+## Segurança (combinar com `skill-security`)
+
+- Hash com `@node-rs/argon2` (Argon2id)
+- JWT RS256 público, HS256+secret≥256bits interno
+- `helmet` middleware para headers
+- CORS específico
+- Rate limit em login (5/15min)
+- Refresh token com rotação no DB
+
+---
+
+## CI
+
+```bash
+npm run lint
+npm run test
+npm run test:e2e
+npm run build
+npx prisma migrate deploy --dry-run
+npm audit --audit-level=high
+```
+
+---
+
+## Aplicação por fase DARE
+
+### Design
+- Listar endpoints REST com tags e métodos
+- Definir DTOs de input e output
+- Auth strategy escolhida
+
+### Blueprint
+- Estrutura de módulos
+- Prisma schema preliminar
+- Endpoints com `@ApiOperation` documentados
+
+### Tasks
+- Por módulo: 4 tasks (Module, Controller+DTO, Service, Repository)
+- Task de configuração Swagger + throttler + global filter
+
+### Execute
+- Ralph Loop:
+  ```bash
+  npm run lint && npm run test && npm run test:e2e && npm run build
+  ```
+
+---
+
+## Checklist final
+
+- [ ] `strict: true` no tsconfig
+- [ ] Todos os Controllers usam DTOs com class-validator
+- [ ] `ValidationPipe` global em main.ts
+- [ ] Services injetáveis (não `new`)
+- [ ] Repositories encapsulam Prisma
+- [ ] OpenAPI gerado em `public/openapi.json`
+- [ ] ThrottlerModule global + endpoints sensíveis com `@Throttle`
+- [ ] AllExceptionsFilter global
+- [ ] Auth via `JwtAuthGuard` + secret via env
+- [ ] Testes unit + E2E
+
+---
+
+Skill licenciada MIT — parte do DARE Method v3.

package/templates/ide/cursor/.cursor/rules/skill-quality-telemetry.mdc

@@ -0,0 +1,248 @@
+---
+description: Coleta de métricas de qualidade e detecção de regressões em projetos DARE. Agrega métricas das skills filhas (dare-ax, dare-layered-design, etc.), persiste histórico em tmp/dare_metrics.json e detecta regressões contra baseline.
+globs: dare.config.yml,tmp/dare_metrics*.json,.github/workflows/dare-metrics.yml
+alwaysApply: false
+---
+
+# Skill: Quality Telemetry DARE
+
+Você é um engenheiro de plataforma especialista em observabilidade de qualidade. Esta skill agrega as métricas de todas as skills DARE aplicadas no projeto (ax, layered-design, llm-integration, frontend-design, realtime) e detecta regressões.
+
+## O que essa skill faz
+
+1. **Coleta** — roda collectors de cada skill filha em paralelo
+2. **Agrega** — junta tudo em um snapshot estruturado
+3. **Persiste** — `tmp/dare_metrics.json` (append-only)
+4. **Compara** — diff contra `tmp/dare_metrics_baseline.json`
+5. **Reporta** — markdown report no CI ou stdout
+6. **Bloqueia** — exit code ≠ 0 se regressão crítica detectada
+
+---
+
+## Arquitetura
+
+```
+┌────────────────────────────────────────────────────────────┐
+│  collect.ts (orquestrador)                                  │
+└────────────────────────────────────────────────────────────┘
+              ↓ paralelo
+┌───────────────┬──────────────┬──────────────┬──────────────┐
+│ ax collector  │ layered      │ llm          │ realtime …   │
+└───────────────┴──────────────┴──────────────┴──────────────┘
+              ↓
+┌────────────────────────────────────────────────────────────┐
+│  Aggregator → snapshot { skill: { M-01: value, status } }   │
+└────────────────────────────────────────────────────────────┘
+              ↓
+┌────────────────────────────────────────────────────────────┐
+│  tmp/dare_metrics.json (append) + Regression detector       │
+└────────────────────────────────────────────────────────────┘
+              ↓
+┌────────────────────────────────────────────────────────────┐
+│  Reporter → markdown / JSON / GH Actions step summary       │
+└────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Métricas (da própria skill)
+
+| ID | Métrica | Como medir |
+|---|---|---|
+| M-01 | 100% dos builds incluem coleta | skill instalada = sempre true |
+| M-02 | 0 regressões passam despercebidas | `test -f tmp/dare_metrics_baseline.json` |
+| M-03 | Histórico mantido | `test -f tmp/dare_metrics.json` e tem N entradas |
+| M-04 | Workflow GH Actions existe | `test -f .github/workflows/dare-metrics.yml` |
+
+---
+
+## Configuração `dare.config.yml`
+
+```yaml
+telemetry:
+  skills:
+    - dare-ax
+    - dare-layered-design
+    - dare-llm-integration
+    - dare-frontend-design
+    - dare-realtime
+  output: tmp/dare_metrics.json
+  baseline: tmp/dare_metrics_baseline.json
+  fail_on_regression: true
+  regression_threshold_critical: 0.05  # ≥5% queda = CRITICAL
+  regression_threshold_warning: 0.01   # ≥1% queda = WARNING
+```
+
+---
+
+## Schema do snapshot
+
+```json
+{
+  "timestamp": "2026-05-26T10:30:00Z",
+  "commit": "1d4a1417",
+  "branch": "main",
+  "skills": {
+    "dare-ax": {
+      "M-01": { "value": 1.0, "status": "PASS", "details": "llms.txt válido" },
+      "M-02": { "value": 1.0, "status": "PASS" },
+      "M-03": { "value": 1.0, "status": "PASS" },
+      "M-04": { "value": 1.0, "status": "PASS" }
+    },
+    "dare-layered-design": {
+      "M-01": { "value": 0.95, "status": "PASS", "details": "19/20 services com teste" },
+      "M-02": { "value": 1.0, "status": "PASS" },
+      "M-03": { "value": 1.0, "status": "PASS" },
+      "M-04": { "value": 1.0, "status": "PASS" }
+    }
+  },
+  "summary": {
+    "totalMetrics": 24,
+    "passing": 23,
+    "failing": 1,
+    "warningRegressions": 0,
+    "criticalRegressions": 0
+  }
+}
+```
+
+---
+
+## Detecção de regressão
+
+Para cada métrica, comparar valor atual com `baseline`:
+
+| Mudança | Severidade | Ação |
+|---|---|---|
+| value caiu ≥ 5% | CRITICAL | exit 1 — bloqueia PR |
+| value caiu ≥ 1% e < 5% | WARNING | comentar no PR — não bloqueia |
+| value subiu | INFO | celebrar no report |
+| value igual | NEUTRAL | nenhuma |
+
+Configurar thresholds em `dare.config.yml`.
+
+---
+
+## Workflow GitHub Actions
+
+```yaml
+# .github/workflows/dare-metrics.yml
+name: DARE Metrics
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  metrics:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: actions/setup-node@v4
+        with: { node-version: '20' }
+      - run: pnpm install --frozen-lockfile
+      - name: Collect DARE metrics
+        run: pnpm dare metrics collect
+      - name: Compare against baseline
+        run: pnpm dare metrics compare
+        # exit 1 se regressão CRITICAL
+      - name: Upload metrics artifact
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dare-metrics-${{ github.sha }}
+          path: tmp/dare_metrics*.json
+      - name: Comment on PR
+        if: github.event_name == 'pull_request'
+        run: pnpm dare metrics report --markdown >> $GITHUB_STEP_SUMMARY
+```
+
+---
+
+## Antipatterns
+
+| AP | Antipattern | Por que evitar |
+|---|---|---|
+| AP-01 | Coletar sem baseline | Não dá pra detectar regressão |
+| AP-02 | Histórico não versionado | Perde contexto histórico |
+| AP-03 | Coletar mas não bloquear | CI vira teatro |
+| AP-04 | Baseline desatualizado | Regressão real fica invisível |
+| AP-05 | Métricas opacas (sem `details`) | Difícil debugar quando falha |
+
+---
+
+## Custom collectors
+
+Para métricas específicas do projeto (cobertura, build time, lighthouse score, etc.), criar collector custom:
+
+```typescript
+// src/telemetry/coverage_collector.ts
+export const coverageCollector: DareCollector = {
+  name: 'project-coverage',
+  async collect() {
+    const cov = await readCoverageReport('coverage/coverage-summary.json');
+    return {
+      'CV-01': { value: cov.lines.pct / 100, status: cov.lines.pct > 80 ? 'PASS' : 'FAIL' },
+      'CV-02': { value: cov.branches.pct / 100, status: cov.branches.pct > 70 ? 'PASS' : 'FAIL' },
+    };
+  },
+};
+```
+
+Registrar em `dare.config.yml`:
+```yaml
+telemetry:
+  customCollectors:
+    - src/telemetry/coverage_collector.ts
+```
+
+---
+
+## Aplicação por fase DARE
+
+### Design
+- Documentar quais métricas serão coletadas
+- Definir baselines de qualidade (cobertura ≥ X%, etc.)
+
+### Blueprint
+- Decidir frequência de baseline update (por release? por sprint?)
+- Thresholds CRITICAL e WARNING
+
+### Tasks
+- Task: instalar `@dare/quality-telemetry`
+- Task: configurar `dare.config.yml`
+- Task: rodar primeira coleta e capturar baseline
+- Task: adicionar workflow CI
+
+### Execute
+- Em cada PR, CI roda coleta + compare
+- Regressão CRITICAL = bloqueia merge
+- Regressão WARNING = comenta no PR
+
+---
+
+## Boas práticas
+
+1. **Baseline por release**, não por commit — evita "shift baseline" silencioso
+2. **Regressão = bloqueio**, não comentário ignorável
+3. **Exportar para Datadog/Grafana** após N coletas — visualizar tendência
+4. **Collectors paralelos** — total deve rodar em < 60s
+5. **Métricas com `details`** — quando falhar, fácil de debugar
+
+---
+
+## Checklist final
+
+- [ ] `@dare/quality-telemetry` instalada
+- [ ] `dare.config.yml` lista as skills a rastrear
+- [ ] Primeira coleta gerou `tmp/dare_metrics.json`
+- [ ] Baseline capturado em `tmp/dare_metrics_baseline.json`
+- [ ] Workflow `.github/workflows/dare-metrics.yml` existe
+- [ ] Thresholds CRITICAL/WARNING definidos
+- [ ] `fail_on_regression: true` em produção
+
+---
+
+Skill licenciada MIT — parte do DARE Method v3.