# MORPH Design - FASE 2

Expanda a proposta em especificação técnica completa, contracts, decisões arquiteturais e estimativa de custos.

## Uso

```
/morph-design {feature-name}
```

## Pré-requisitos

- [ ] FASE 1 (Setup) concluída
- [ ] FASE 1.5 (UI/UX) concluída OU pulada (se não houver front-end)
- [ ] Proposta aprovada pelo usuário

## Workflow

### Passo 1: Carregar Contexto

Leia os arquivos existentes da feature:

```bash
# Verificar outputs existentes
node bin/state-manager.js get {feature-name}
```

Leia:
1. `.morph/project/outputs/{feature}/proposal.md` - Proposta inicial
2. `.morph/project/outputs/{feature}/ui-*.md` - UI/UX specs (se existirem)
3. `framework/standards/` e `.morph/project/standards/` - Padrões aplicáveis

### Passo 2: Gerar `spec.md`

Crie `.morph/project/outputs/{feature}/spec.md` com:

#### 2.1. Overview
- **Objetivo:** Resumo de 1-2 parágrafos
- **Usuários afetados:** Quem vai usar?
- **Problema resolvido:** Qual dor/necessidade?

#### 2.2. Functional Requirements
Lista detalhada de requisitos funcionais:
```markdown
### FR001: {Requisito}
**Description:** {O que deve fazer}
**Acceptance Criteria:**
- [ ] Critério 1
- [ ] Critério 2
**Priority:** High/Medium/Low
```

#### 2.3. Non-Functional Requirements
- Performance (tempos de resposta esperados)
- Segurança (autenticação, autorização)
- Escalabilidade (volume de dados/usuários)
- Disponibilidade (uptime esperado)

#### 2.4. Technical Architecture
- **Camadas:** (Presentation, Application, Domain, Infrastructure)
- **Patterns:** (Repository, CQRS, DI, etc.)
- **Dependências:** Bibliotecas/serviços externos necessários

#### 2.5. Data Model
- Entities principais
- Relacionamentos (1:1, 1:N, N:N)
- Campos obrigatórios vs opcionais
- Validações de negócio

#### 2.6. Infrastructure Requirements
Se houver recursos Azure:
- Banco de dados (Azure SQL, Cosmos DB)
- Storage (Blob Storage)
- Compute (Container Apps, App Service)
- Monitoring (App Insights)

**SEMPRE usar Bicep para infra!**

### Passo 3: Gerar `contracts.cs`

Crie `.morph/project/outputs/{feature}/contracts.cs` com:

```csharp
// Interfaces, DTOs, Enums, Value Objects

namespace {ProjectName}.Features.{FeatureName};

// DTOs (Data Transfer Objects)
public record {Feature}CreateDto(
    string Name,
    DateTime Date
);

public record {Feature}ResponseDto(
    Guid Id,
    string Name,
    DateTime Date,
    DateTime CreatedAt
);

// Interfaces
public interface I{Feature}Service
{
    Task<{Feature}ResponseDto> CreateAsync({Feature}CreateDto dto, CancellationToken ct);
    Task<{Feature}ResponseDto?> GetByIdAsync(Guid id, CancellationToken ct);
}

// Enums
public enum {Feature}Status
{
    Pending,
    Active,
    Completed
}
```

**Padrões obrigatórios:**
- Records para DTOs (immutable)
- Interfaces para serviços
- CancellationToken em métodos async
- Nullable reference types habilitados

### Passo 4: Iniciar `decisions.md`

Crie `.morph/project/outputs/{feature}/decisions.md` com ADRs relevantes:

```markdown
# Architectural Decision Records (ADRs)

## ADR-001: {Decisão Arquitetural}

**Status:** Proposed/Accepted/Deprecated

**Context:**
{Por que esta decisão foi necessária}

**Decision:**
{O que foi decidido}

**Consequences:**
**Pros:**
- Pro 1
- Pro 2

**Cons:**
- Con 1
- Con 2

**Alternatives Considered:**
- Alternativa 1: {Por que foi rejeitada}
- Alternativa 2: {Por que foi rejeitada}

**Date:** {YYYY-MM-DD}

---
```

**ADRs obrigatórios:**
- Escolha de biblioteca UI (se FASE 1.5 executou)
- Padrões arquiteturais (CQRS, Repository, etc.)
- Recursos Azure (se houver infra)
- Integrações externas (APIs, webhooks, etc.)

### Passo 5: Estimar Custos

Se houver recursos Azure na spec (arquivos Bicep):

```bash
# Calcular custos automaticamente
node bin/calculate-costs.js .morph/project/outputs/{feature}/infra/*.bicep --verbose
```

O cost calculator:
- Parseia arquivos Bicep e extrai recursos + SKUs
- Calcula custo mensal baseado em pricing table do Azure
- Valida contra limites configurados em `.morph/config/config.json`
- Exit code 1 se exceder o limite `requiresADR` (padrão: $10)

**Limites configuráveis** (em config.json):
- `costs.limits.freeTierOnly`: $0 (apenas free tier)
- `costs.limits.withApproval`: $10 (requer confirmação do usuário)
- `costs.limits.requiresADR`: $10 (requer ADR documentado)

**Exemplo de output:**
```
╔════════════════════════════════════════════════╗
║         MORPH-SPEC COST CALCULATOR             ║
╠════════════════════════════════════════════════╣
║ sqlDatabase (Basic)              $4.99/mo     ║
║ containerApp (Consumption)       $0.00/mo     ║
║ appInsights (Free)               $0.00/mo     ║
╠════════════════════════════════════════════════╣
║ Total Monthly Cost:              $4.99        ║
║ Requires Approval:               YES          ║
║ Requires ADR:                    NO           ║
╚════════════════════════════════════════════════╝
```

**Documente custos em `decisions.md`:**

```markdown
## ADR-XXX: Infrastructure Costs

**Estimated Monthly Cost:** $X.XX

**Breakdown:**
- Azure SQL Basic: $5.00
- Container App (scale-to-zero): $0.00
- Storage LRS (1GB): $0.02
- App Insights Free: $0.00

**Total:** $5.02/month

**Approval Required:** {Yes/No - based on $10 threshold}

**Justification:**
{Se > $10, justificar aqui}
```

4. Atualizar state com custo:

```bash
node bin/state-manager.js set {feature-name} costs.estimated {X.XX}
node bin/state-manager.js set {feature-name} costs.approved {true/false}
```

### Passo 6: Atualizar State

```bash
# Marcar fase como design
node bin/state-manager.js set {feature-name} phase design

# Marcar outputs criados
node bin/state-manager.js mark-output {feature-name} spec
node bin/state-manager.js mark-output {feature-name} contracts
node bin/state-manager.js mark-output {feature-name} decisions
```

## Outputs Gerados

- `.morph/project/outputs/{feature}/spec.md` - Especificação técnica completa
- `.morph/project/outputs/{feature}/contracts.cs` - Interfaces, DTOs, Enums
- `.morph/project/outputs/{feature}/decisions.md` - ADRs (novo ou atualizado)
- State atualizado com custos estimados

## ⛔ PAUSA OBRIGATÓRIA

Apresente ao usuário 3 ações sugeridas:

1. ✅ **Aprovar design e continuar para clarificação**
   Prosseguir para `/morph-clarify` (FASE 3)

2. 🔄 **Ajustar escopo/complexidade**
   Revisar spec.md para reduzir ou expandir funcionalidades

3. 💰 **Revisar custos estimados** (se houver recursos Azure)
   Ajustar SKUs ou recursos para ficar dentro do budget

4. 📋 **Modificar contracts**
   Ajustar interfaces/DTOs se necessário

**Formato:** Escolher 3 das opções acima, contextualizadas para a feature

## Critérios de Avanço

- [x] `spec.md` completo com todos os requisitos
- [x] `contracts.cs` com interfaces e DTOs
- [x] `decisions.md` com ADRs relevantes
- [x] Custos estimados e documentados (se houver infra)
- [x] State atualizado
- [x] Usuário aprovou design

---

**Feature:** $ARGUMENTS
