@polymorphism-tech/morph-spec 1.0.4 → 2.0.0

package/content/.claude/commands/morph-clarify.md

@@ -0,0 +1,184 @@
+# MORPH Clarify - FASE 3
+
+Identifique ambiguidades na especificação e faça perguntas de clarificação para garantir que todos os edge cases estão cobertos.
+
+## Uso
+
+```
+/morph-clarify {feature-name}
+```
+
+## Pré-requisitos
+
+- [ ] FASE 2 (Design) concluída
+- [ ] `spec.md` aprovado pelo usuário
+- [ ] `contracts.cs` definidos
+
+## Workflow
+
+### Passo 1: Analisar Spec
+
+Leia `.morph/project/outputs/{feature}/spec.md` em detalhes e identifique:
+
+#### 1.1. Ambiguidades
+- Requisitos vagos ou genéricos
+- Termos sem definição clara
+- Comportamentos não especificados
+
+#### 1.2. Edge Cases Não Documentados
+- O que acontece se...?
+- Como lidar com entradas inválidas?
+- Comportamento em caso de erro?
+- Estados intermediários (loading, empty)
+
+#### 1.3. Requisitos Conflitantes
+- Duas funcionalidades que parecem incompatíveis
+- Prioridades não claras (o que vem primeiro?)
+
+#### 1.4. Dados Faltantes
+- Validações de negócio não especificadas
+- Limites e constraints (tamanhos, quantidades)
+- Formatos de dados (datas, moedas, etc.)
+
+### Passo 2: Gerar Perguntas de Clarificação
+
+Com base na análise, gere **3-7 perguntas** focadas e específicas:
+
+**Formato de pergunta:**
+```markdown
+### Q{N}: {Categoria} - {Título}
+
+**Context:** {Por que esta pergunta é importante}
+
+**Question:** {Pergunta clara e objetiva}
+
+**Options (if applicable):**
+- A) {Opção 1}
+- B) {Opção 2}
+- C) {Deixar em aberto/usuário decidir}
+
+**Impact:** {Como a resposta afeta a implementação}
+```
+
+**Exemplo:**
+
+```markdown
+### Q1: Validação - Limite de Nome de Projeto
+
+**Context:** O spec menciona "nome de projeto" mas não especifica limites.
+
+**Question:** Qual o comprimento máximo do nome de projeto?
+
+**Options:**
+- A) 50 caracteres (padrão curto)
+- B) 100 caracteres (padrão médio)
+- C) 255 caracteres (padrão longo)
+- D) Sem limite (validar apenas se não vazio)
+
+**Impact:** Afeta validação do DTO, schema do banco, e UI (tamanho do input).
+```
+
+### Passo 3: Categorizar Perguntas
+
+Organize perguntas por categoria:
+
+| Categoria | Descrição | Exemplos |
+|-----------|-----------|----------|
+| **Validação** | Regras de negócio, constraints | Limites de tamanho, formatos aceitos |
+| **Comportamento** | O que acontece quando... | Error handling, estados vazios |
+| **Prioridade** | O que é must-have vs nice-to-have | MVP vs futuras iterações |
+| **Integração** | Como interage com sistemas externos | APIs, webhooks, formato de dados |
+| **Performance** | Requisitos de velocidade/volume | Quantos registros? Tempo de resposta? |
+| **UX** | Experiência do usuário | Feedback visual, mensagens de erro |
+
+### Passo 4: Apresentar Perguntas ao Usuário
+
+Liste todas as perguntas de forma clara e estruturada.
+
+**IMPORTANTE:** Não prossiga para próxima fase até ter respostas!
+
+### Passo 5: Atualizar `spec.md` com Respostas
+
+Após receber respostas do usuário, atualize o spec com:
+
+1. **Seção de Clarificações** no início do spec:
+```markdown
+## Clarifications (FASE 3)
+
+### Q1: {Título}
+**Answer:** {Resposta do usuário}
+**Date:** {YYYY-MM-DD}
+
+### Q2: {Título}
+**Answer:** {Resposta do usuário}
+**Date:** {YYYY-MM-DD}
+```
+
+2. **Atualizar seções relevantes** com detalhes adicionados:
+   - Requisitos funcionais mais específicos
+   - Validações documentadas
+   - Edge cases cobertos
+
+### Passo 6: Validar Edge Cases
+
+Documente no spec como lidar com cada edge case identificado:
+
+```markdown
+## Edge Cases
+
+### EC001: {Nome do Edge Case}
+**Scenario:** {Quando acontece}
+**Expected Behavior:** {Como o sistema deve reagir}
+**Implementation Notes:** {Dicas para implementação}
+
+**Example:**
+- Input: {exemplo de entrada problemática}
+- Output: {comportamento esperado}
+```
+
+### Passo 7: Atualizar State
+
+```bash
+# Marcar fase como clarify
+node bin/state-manager.js set {feature-name} phase clarify
+
+# State permanece in_progress até usuário responder todas as perguntas
+```
+
+## Outputs Gerados/Atualizados
+
+- `.morph/project/outputs/{feature}/spec.md` - Atualizado com:
+  - Seção "Clarifications" com perguntas e respostas
+  - Edge cases documentados
+  - Requisitos mais específicos
+
+## ⛔ PAUSA OBRIGATÓRIA
+
+Apresente perguntas de clarificação e aguarde respostas do usuário.
+
+**Não prossiga até ter todas as respostas!**
+
+Após receber respostas, atualizar spec e apresentar:
+
+1. ✅ **Aprovar clarificações e continuar para tasks**
+   Prosseguir para `/morph-tasks` (FASE 4)
+
+2. 🔄 **Fazer mais perguntas** (se ainda houver dúvidas)
+   Iterar novamente nesta fase
+
+3. 📋 **Revisar spec atualizado**
+   Validar que clarificações foram bem incorporadas
+
+## Critérios de Avanço
+
+- [x] Perguntas de clarificação identificadas (3-7)
+- [x] Perguntas apresentadas ao usuário
+- [x] Respostas do usuário recebidas
+- [x] `spec.md` atualizado com clarificações
+- [x] Edge cases documentados
+- [x] State atualizado
+- [x] Nenhuma ambiguidade crítica remanescente
+
+---
+
+**Feature:** $ARGUMENTS

package/content/.claude/commands/morph-design.md

@@ -0,0 +1,275 @@
+# 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

package/content/.claude/commands/morph-proposal.md

@@ -5,56 +5,97 @@ Crie uma nova proposta de feature seguindo o workflow MORPH.
 ## Contexto
 
 Leia os seguintes arquivos para entender o projeto:
-- `.morph/project.md` - Contexto e convenções do projeto
-- `.morph/standards/` - Padrões técnicos
+- `.morph/project/context/README.md` - Contexto do projeto
+- `framework/standards/` e `.morph/project/standards/` - Padrões técnicos
 - `.morph/config/agents.json` - Agentes disponíveis
 
 ## Workflow
 
-1. **Analise a solicitação** e identifique:
+1. **Detecte agentes automaticamente**:
+   ```bash
+   node bin/detect-agents.js "$ARGUMENTS"
+   ```
+   Isso retorna quais agentes devem ser ativados baseado em keywords.
+
+2. **Invoque skills dos agentes detectados**:
+   - Para agentes com `skillPath` em agents.json, invoque o Skill correspondente
+   - Exemplo: Se detectou `uiux-designer`, consulte `.claude/skills/specialists/ui-ux-designer.md`
+   - Skills contêm conhecimento especializado, workflows e prompts detalhados
+   - Use conhecimento dos skills para enriquecer a proposta
+
+3. **Analise a solicitação** e identifique:
    - Problema a resolver
    - Usuários afetados
    - Impacto esperado
 
-2. **Crie a estrutura da feature**:
+4. **Crie a estrutura da feature**:
    ```
-   .morph/features/{feature-name}/
+   .morph/project/outputs/{feature-name}/
    ├── proposal.md    # Proposta inicial
    ├── spec.md        # Especificação técnica (iniciar)
-   └── tasks.md       # Lista de tasks (iniciar)
+   └── tasks.json     # Lista de tasks (iniciar)
    ```
 
-3. **Preencha `proposal.md`** baseado em `.morph/templates/proposal.md`:
+5. **Preencha `proposal.md`** baseado em `framework/templates/proposal.md`:
    - Problem Statement
    - Proposed Solution
    - Success Metrics
    - Scope (In/Out)
    - Estimated Effort
    - Cost Impact
+   - **Agents Activated** (lista dos agentes detectados)
 
-4. **Inicie `spec.md`** com:
+6. **Inicie `spec.md`** com:
    - User Stories principais
    - Arquitetura proposta
    - Data Model inicial
 
-5. **Inicie `tasks.md`** com:
-   - Tasks de alto nível identificadas
+7. **Inicie `tasks.json`** com:
+   - Tasks de alto nível identificadas (formato JSON)
    - Checkpoints sugeridos
 
-6. **Ative agentes especializados** baseado nas keywords:
-   - ⏰ Hangfire: scheduled, job, background
-   - 🎨 UI/UX: wizard, dashboard, complex
-   - 📋 PO/PM: unclear, requirements, priority
+## State Management
+
+Após criar o proposal, **SEMPRE** registre a feature no state.json:
+
+```bash
+# Criar entrada no state
+node bin/state-manager.js set {feature-name} status draft
+node bin/state-manager.js set {feature-name} phase proposal
+
+# Marcar output como criado
+node bin/state-manager.js mark-output {feature-name} proposal
+
+# Adicionar agentes ativados (todos os detectados)
+# Parsear output do detect-agents.js e adicionar cada um:
+for agent in $(node bin/detect-agents.js --ids-only "$ARGUMENTS"); do
+  node bin/state-manager.js add-agent {feature-name} $agent
+done
+```
+
+**Exemplo completo:**
+```bash
+# Detectar e registrar agentes
+AGENTS=$(node bin/detect-agents.js --ids-only "implementar dashboard com charts")
+# Retorna: standards-architect, azure-architect, ..., uiux-designer
+
+# Para cada agente
+echo "$AGENTS" | while read agent; do
+  node bin/state-manager.js add-agent my-feature "$agent"
+done
+```
 
 ## Output
 
 Ao final, apresente:
 1. Resumo da proposta
-2. Agentes ativados
+2. Agentes ativados (e registrados no state)
 3. Custo estimado
 4. Perguntas de clarificação (se houver)
 5. Solicitar aprovação para prosseguir para DESIGN
 
+**IMPORTANTE:** Confirme que a feature foi registrada no state.json executando `node bin/state-manager.js list`.
+
 ---
 
 **Feature solicitada:** $ARGUMENTS

package/content/.claude/commands/morph-setup.md

@@ -0,0 +1,100 @@
+# MORPH Setup - FASE 1
+
+Inicialize o contexto e prepare o ambiente para uma feature aprovada.
+
+## Uso
+
+```
+/morph-setup {feature-name}
+```
+
+## Pré-requisitos
+
+- [ ] Feature tem `proposal.md` criado (FASE 0 concluída)
+- [ ] Proposal foi aprovado pelo usuário
+- [ ] Agentes foram detectados e registrados no state
+
+## Workflow
+
+### Passo 1: Verificar State
+
+Confirme que a feature existe no state:
+
+```bash
+node bin/state-manager.js get {feature-name}
+```
+
+Se não existir, volte para `/morph-proposal`.
+
+### Passo 2: Carregar Contexto do Projeto
+
+Leia os seguintes arquivos para entender o projeto:
+
+1. **Contexto geral**:
+   - `.morph/project/context/README.md` - Overview do projeto
+   - `.morph/config.json` - Configurações
+
+2. **Standards do framework**:
+   - `framework/standards/coding.md` - Padrões de código
+   - `framework/standards/architecture.md` - Padrões de arquitetura
+   - `framework/standards/azure.md` - Padrões Azure e IaC
+
+3. **Standards do projeto** (sobrescrevem framework se existirem):
+   - `.morph/project/standards/coding.md`
+   - `.morph/project/standards/architecture.md`
+   - `.morph/project/standards/inferred.md` - Standards detectados
+
+### Passo 3: Confirmar Stack
+
+Baseado no proposal e contexto, confirme:
+- Stack tecnológica (Blazor Server, Next.js, Shopify, etc.)
+- Padrões arquiteturais aplicáveis
+- Componentes reutilizáveis existentes
+
+### Passo 4: Listar Agentes Ativos
+
+Mostre os agentes detectados no proposal:
+
+```bash
+node bin/state-manager.js get {feature-name}
+```
+
+Parse o JSON e liste os `activeAgents` com seus emojis e responsabilidades (consulte `.morph/config/agents.json`).
+
+### Passo 5: Atualizar State
+
+Marque a feature como na fase SETUP:
+
+```bash
+node bin/state-manager.js set {feature-name} phase setup
+node bin/state-manager.js set {feature-name} status in_progress
+```
+
+## Outputs
+
+**Apresente ao usuário:**
+
+1. **Contexto carregado**:
+   - Nome do projeto
+   - Stack confirmado
+   - Standards aplicáveis
+
+2. **Agentes ativos**:
+   - Lista de agentes com emojis
+   - Responsabilidades de cada um
+
+3. **Próximos passos**:
+   - Se feature tem UI/UX keywords → `/morph-uiux` (FASE 1.5)
+   - Se NÃO tem UI/UX → `/morph-design` (FASE 2)
+
+## Critérios de Avanço
+
+- [x] Contexto do projeto carregado
+- [x] Standards identificados (framework + project)
+- [x] Stack confirmado
+- [x] Agentes listados
+- [x] State atualizado para phase: setup
+
+---
+
+**Feature:** $ARGUMENTS