@polymorphism-tech/morph-spec 1.0.4 → 2.0.0

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

@@ -2,63 +2,78 @@
 
 Mostre o status atual do projeto MORPH e features em desenvolvimento.
 
-## O que verificar
+## Como Usar
+
+**SEMPRE** use o state-manager CLI para obter status:
+
+```bash
+node bin/state-manager.js list
+```
+
+Este comando automaticamente mostra:
+- Todas as features ativas
+- Fase atual de cada feature
+- Progresso de tasks (X/Y)
+- Agentes ativos
+- Custos estimados
+
+## Verificações Adicionais
 
 ### 1. Configuração MORPH
 - [ ] `.morph/project.md` existe e está preenchido
 - [ ] `.morph/config/config.json` configurado
 - [ ] `.morph/standards/` presentes
 
-### 2. Features Ativas
+### 2. Detalhes de Feature Específica
 
-Verifique `.morph/features/` e para cada feature:
+Para obter JSON detalhado de uma feature:
 
-```
-Feature: {name}
-├── Status: {Draft|In Review|Approved|In Progress|Done}
-├── Phase: {Proposal|Design|Clarify|Tasks|Implement}
-├── Progress: {X}/{Y} tasks
-├── Agents: {lista de agentes ativos}
-└── Cost: ${X}/month estimated
+```bash
+node bin/state-manager.js get {feature-name}
 ```
 
 ### 3. Features Arquivadas
 
-Verifique `.morph/archive/` e liste:
+Verifique `.morph/project/archive/` manualmente se necessário:
 - Quantas features concluídas
 - Tempo total gasto
 - Custo acumulado
 
 ### 4. Specs Ativas
 
-Verifique `.morph/specs/` para specs consolidadas.
+Verifique `.morph/project/specs/` para specs consolidadas.
 
 ## Output
 
-Apresente um dashboard como:
+O comando `node bin/state-manager.js list` automaticamente gera um dashboard formatado:
 
 ```
-╔════════════════════════════════════════════╗
-║           MORPH PROJECT STATUS             ║
-╠════════════════════════════════════════════╣
-║ Project: {name}                            ║
-║ Type: Blazor Server                        ║
-╠════════════════════════════════════════════╣
-║ FEATURES IN PROGRESS                       ║
-╠════════════════════════════════════════════╣
-║ 📝 {feature-1}                             ║
-║    Phase: Implement | Tasks: 5/12          ║
-║    Agents: 📐☁️🔥🗄️💰                      ║
-╠════════════════════════════════════════════╣
-║ 📝 {feature-2}                             ║
-║    Phase: Design | Tasks: 0/0              ║
-║    Agents: 📐☁️🔥🗄️💰⏰                    ║
-╠════════════════════════════════════════════╣
-║ ARCHIVED: 3 features                       ║
-║ TOTAL COST: ~$12/month                     ║
-╚════════════════════════════════════════════╝
+╔════════════════════════════════════════════════════════════════╗
+║                    MORPH-SPEC PROJECT STATUS                   ║
+╠════════════════════════════════════════════════════════════════╣
+║ Project: {PROJECT_NAME}                                        ║
+║ Type: blazor-server                                            ║
+╠════════════════════════════════════════════════════════════════╣
+║ FEATURES                                                       ║
+╠════════════════════════════════════════════════════════════════╣
+║ 📝 {feature-1}                                                 ║
+║    Phase: implement        │ Tasks: 5/12                       ║
+║    Agents: blazor-builder ef-modeler hangfire-orchestrator     ║
+╠════════════════════════════════════════════════════════════════╣
+║ 📝 {feature-2}                                                 ║
+║    Phase: design           │ Tasks: 0/0                        ║
+║    Agents: None                                                ║
+╠════════════════════════════════════════════════════════════════╣
+║ SUMMARY                                                        ║
+╠════════════════════════════════════════════════════════════════╣
+║ Total Features: 2                                              ║
+║ Completed: 0                                                   ║
+║ Estimated Cost: $5.50/month                                    ║
+╚════════════════════════════════════════════════════════════════╝
 ```
 
+**Simplesmente execute o comando e mostre o resultado ao usuário.**
+
 ## Ações Disponíveis
 
 Sugira próximas ações:

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

@@ -0,0 +1,319 @@
+# MORPH Tasks - FASE 4
+
+Quebre a especificação em tasks executáveis, defina ordem de execução e estabeleça checkpoints.
+
+## Uso
+
+```
+/morph-tasks {feature-name}
+```
+
+## Pré-requisitos
+
+- [ ] FASE 3 (Clarify) concluída
+- [ ] `spec.md` atualizado com clarificações
+- [ ] Todos os edge cases documentados
+
+## Workflow
+
+### Passo 1: Analisar Spec
+
+Leia `.morph/project/outputs/{feature}/spec.md` e identifique:
+
+1. **Requisitos funcionais** (FR001, FR002, ...)
+2. **Componentes técnicos** (Entities, Services, Controllers, Pages)
+3. **Infraestrutura** (Bicep, migrations, configs)
+4. **Testes** (Unit tests, integration tests)
+
+### Passo 2: Quebrar em Tasks
+
+Crie tasks no formato **T{NNN}** seguindo ordem lógica de implementação.
+
+#### 2.1. Estrutura de Task
+
+```json
+{
+  "id": "T001",
+  "title": "Criar Entity {Nome}",
+  "description": "Implementar entity {Nome} com propriedades X, Y, Z seguindo padrões EF Core",
+  "category": "domain",
+  "dependencies": [],
+  "estimatedMinutes": 30,
+  "status": "pending",
+  "files": [
+    "Domain/Entities/{Nome}.cs",
+    "Infrastructure/Data/Configurations/{Nome}Configuration.cs"
+  ]
+}
+```
+
+#### 2.2. Categorias de Tasks
+
+| Categoria | Descrição | Exemplos |
+|-----------|-----------|----------|
+| **domain** | Entities, Value Objects, Enums | Entity, DomainException |
+| **application** | Services, DTOs, Interfaces | Service, Validator, Mapper |
+| **infrastructure** | DbContext, Repositories, External APIs | EF Config, Repository impl |
+| **presentation** | Controllers, Pages, Components | API endpoint, Blazor page |
+| **tests** | Unit tests, Integration tests | Service tests, API tests |
+| **infra** | Bicep, Migrations, Scripts | Azure resources, DB migration |
+| **docs** | README, API docs, Swagger | OpenAPI spec, README update |
+
+#### 2.3. Ordem de Implementação
+
+**Bottom-up approach:**
+```
+1. Domain (Entities, Enums, Value Objects)
+   ↓
+2. Infrastructure (Repositories, DbContext configs)
+   ↓
+3. Application (Services, DTOs, Business logic)
+   ↓
+4. Presentation (Controllers, Pages, Components)
+   ↓
+5. Tests (Unit → Integration)
+   ↓
+6. Infra (Bicep, Migrations, Deploy scripts)
+   ↓
+7. Docs (README, Swagger, Comments)
+```
+
+### Passo 3: Definir Dependências
+
+Para cada task, especifique dependências:
+
+```json
+{
+  "id": "T005",
+  "title": "Criar {Nome}Service",
+  "dependencies": ["T001", "T002"], // Precisa de Entities primeiro
+  "status": "pending"
+}
+```
+
+**Regra:** Task só pode ser executada quando todas as dependências estão `completed`.
+
+### Passo 4: Estabelecer Checkpoints
+
+Defina checkpoints a cada **3 tasks** ou **marcos significativos**:
+
+```json
+{
+  "id": "CHECKPOINT_001",
+  "title": "Domain Layer Completo",
+  "afterTasks": ["T001", "T002", "T003"],
+  "validations": [
+    "Todas as entities criadas",
+    "Migrations aplicadas",
+    "Testes de domain passando"
+  ]
+}
+```
+
+**Checkpoints obrigatórios:**
+- Após domain layer
+- Após infrastructure layer
+- Após application layer
+- Após presentation layer
+- Antes de deploy (final)
+
+### Passo 5: Estimar Esforço
+
+Para cada task, estime tempo em minutos:
+
+| Complexidade | Tempo Estimado |
+|--------------|----------------|
+| Trivial (CRUD básico) | 15-30 min |
+| Simples (Service, Controller) | 30-60 min |
+| Média (Business logic, validações) | 60-120 min |
+| Complexa (Integrações, AI) | 120-240 min |
+
+**Total:** Some todos os tempos para estimar esforço total da feature.
+
+### Passo 6: Gerar `tasks.json`
+
+Crie `.morph/project/outputs/{feature}/tasks.json`:
+
+```json
+{
+  "feature": "{feature-name}",
+  "totalTasks": 15,
+  "estimatedHours": 8.5,
+  "checkpoints": [
+    {
+      "id": "CHECKPOINT_001",
+      "title": "Domain Layer Completo",
+      "afterTasks": ["T001", "T002", "T003"]
+    },
+    {
+      "id": "CHECKPOINT_002",
+      "title": "Application Layer Completo",
+      "afterTasks": ["T006", "T007", "T008"]
+    }
+  ],
+  "tasks": [
+    {
+      "id": "T001",
+      "title": "Criar Entity {Nome}",
+      "description": "...",
+      "category": "domain",
+      "dependencies": [],
+      "estimatedMinutes": 30,
+      "status": "pending",
+      "files": ["Domain/Entities/{Nome}.cs"]
+    },
+    {
+      "id": "T002",
+      "title": "Configurar EF para {Nome}",
+      "description": "...",
+      "category": "infrastructure",
+      "dependencies": ["T001"],
+      "estimatedMinutes": 20,
+      "status": "pending",
+      "files": ["Infrastructure/Data/Configurations/{Nome}Configuration.cs"]
+    }
+    // ... mais tasks
+  ]
+}
+```
+
+### Passo 7: Incluir Tasks de IaC (se necessário)
+
+Se houver recursos Azure:
+
+```json
+{
+  "id": "T050",
+  "title": "Criar Bicep para Azure SQL",
+  "description": "Bicep module para Azure SQL Database Basic tier",
+  "category": "infra",
+  "dependencies": ["T001", "T002"], // Domain entities devem existir
+  "estimatedMinutes": 45,
+  "status": "pending",
+  "files": [
+    "infra/modules/sql-database.bicep",
+    "infra/parameters.dev.json"
+  ]
+},
+{
+  "id": "T051",
+  "title": "Criar migration inicial",
+  "description": "EF Core migration com todas as entities",
+  "category": "infra",
+  "dependencies": ["T002", "T003"],
+  "estimatedMinutes": 15,
+  "status": "pending",
+  "files": ["Infrastructure/Data/Migrations/"]
+}
+```
+
+### Passo 8: Atualizar State
+
+```bash
+# Marcar fase como tasks
+node bin/state-manager.js set {feature-name} phase tasks
+
+# Definir total de tasks
+node bin/state-manager.js set {feature-name} tasks.total {N}
+
+# Marcar output tasks criado
+node bin/state-manager.js mark-output {feature-name} tasks
+```
+
+## Outputs Gerados
+
+- `.morph/project/outputs/{feature}/tasks.json` - Breakdown completo de tasks
+
+**Resumo em formato texto:**
+
+Gere também um resumo visual em `.morph/project/outputs/{feature}/tasks-summary.md`:
+
+```markdown
+# Tasks Breakdown - {Feature Name}
+
+## Overview
+- **Total Tasks:** 15
+- **Estimated Time:** 8.5 hours
+- **Checkpoints:** 3
+
+## Tasks by Category
+
+### Domain (3 tasks, 1.5h)
+- T001: Criar Entity {Nome} (30min)
+- T002: Configurar EF para {Nome} (20min)
+- T003: Criar Enum {Status} (15min)
+
+### Infrastructure (4 tasks, 2h)
+- T004: Criar Repository interface (30min)
+- T005: Implementar Repository (60min)
+- ...
+
+### Application (5 tasks, 3h)
+- T006: Criar {Nome}Service (90min)
+- T007: Criar DTOs (45min)
+- ...
+
+### Presentation (3 tasks, 2h)
+- T010: Criar API Controller (60min)
+- T011: Criar Blazor Page (60min)
+- ...
+
+## Checkpoints
+
+### CHECKPOINT_001: Domain Layer Completo
+**After:** T001, T002, T003
+**Validations:**
+- [ ] Entities criadas
+- [ ] EF configurations ok
+- [ ] Compile sem erros
+
+### CHECKPOINT_002: Application Layer Completo
+**After:** T006, T007, T008
+**Validations:**
+- [ ] Services implementados
+- [ ] DTOs validados
+- [ ] Testes unitários passando
+
+## Execution Order
+
+```
+T001 → T002 → T003 → CHECKPOINT_001
+  ↓
+T004 → T005
+  ↓
+T006 → T007 → T008 → CHECKPOINT_002
+  ↓
+T010 → T011 → T012
+  ↓
+T013 → T014 → T015 → CHECKPOINT_003
+```
+```
+
+## ⛔ PAUSA OBRIGATÓRIA
+
+Apresente ao usuário 3 ações sugeridas:
+
+1. ✅ **Aprovar breakdown e iniciar implementação**
+   Prosseguir para `/morph-apply` (FASE 5)
+
+2. 🔀 **Repriorizar tasks**
+   Mudar ordem de execução se necessário
+
+3. ➕ **Adicionar/remover tasks**
+   Ajustar escopo se alguma task foi esquecida ou é desnecessária
+
+## Critérios de Avanço
+
+- [x] `tasks.json` criado com todas as tasks
+- [x] Tasks categorizadas corretamente
+- [x] Dependências mapeadas
+- [x] Checkpoints definidos (a cada 3 tasks)
+- [x] Esforço estimado por task
+- [x] Ordem de execução clara
+- [x] Tasks de IaC incluídas (se aplicável)
+- [x] State atualizado com total de tasks
+- [x] Usuário aprovou breakdown
+
+---
+
+**Feature:** $ARGUMENTS

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

@@ -0,0 +1,211 @@
+# MORPH UI/UX Design - FASE 1.5
+
+Fase obrigatória para features com front-end. Coleta requisitos de UI/UX, gera wireframes, specs de componentes e fluxos de usuário.
+
+## Uso
+
+```
+/morph-uiux {feature-name}
+```
+
+## Pré-requisitos
+
+- [ ] FASE 1 (Setup) concluída
+- [ ] Feature tem keywords de UI detectadas (blazor, ui, component, page, dashboard, wizard, form, chart)
+- [ ] `uiux-designer` agent ativado
+
+## Workflow
+
+### Passo 1: Detectar Se Fase É Necessária
+
+Verifique se agentes ativos incluem `uiux-designer`:
+
+```bash
+node bin/state-manager.js get {feature-name}
+```
+
+Se `uiux-designer` NÃO estiver nos `activeAgents`, pule esta fase e vá para `/morph-design`.
+
+### Passo 2: Coletar Input do Usuário
+
+**SEMPRE perguntar ao usuário PRIMEIRO:**
+
+1. **Layout e estilo**:
+   - Você tem alguma ideia de layout em mente?
+   - Tem alguma referência visual? (sites, apps, screenshots)
+   - Como imagina o fluxo do usuário?
+
+2. **Componentes e interações**:
+   - Quais os principais componentes desta tela/página?
+   - Quais estados precisam ser considerados? (loading, error, empty, success)
+
+3. **Imagens de referência**:
+   - Tem imagens de exemplo que eu possa analisar?
+   - Se SIM: use Read tool para ler screenshots e extrair padrões
+
+### Passo 3: Decidir Biblioteca UI
+
+Escolha entre **Fluent UI Blazor** (recomendado para AI-first) ou **MudBlazor** (componentes complexos):
+
+**Critérios:**
+- Fluent UI: Para dashboards, forms simples, AI components, Microsoft design language
+- MudBlazor: Para data grids avançadas, charts complexos, material design
+
+**Documente a decisão:**
+```bash
+# Adicionar ADR em decisions.md
+echo "## ADR: UI Library Choice
+
+Decision: [Fluent UI / MudBlazor]
+
+Rationale:
+- {Justificativa baseada nos requisitos}
+
+Date: $(date +%Y-%m-%d)" >> .morph/project/outputs/{feature}/decisions.md
+```
+
+### Passo 4: Gerar Deliverables
+
+Crie os seguintes arquivos em `.morph/project/outputs/{feature}/`:
+
+#### 4.1. `ui-design-system.md`
+
+Design system com:
+- Paleta de cores (primary, secondary, accent, semantic)
+- Tipografia (heading scales, body text, code)
+- Spacing e layout (grid, margins, paddings)
+- Componentes base (buttons, inputs, cards)
+
+#### 4.2. `ui-mockups.md`
+
+Wireframes ASCII + descrições:
+- Layout geral de cada tela/página
+- Posicionamento de componentes
+- Responsividade (desktop, tablet, mobile)
+- Estados (loading, error, empty, success)
+
+Exemplo:
+```
+┌─────────────────────────────────────────┐
+│  Header                   [🔔] [👤]     │
+├─────────────────────────────────────────┤
+│ ┌─────────┐                             │
+│ │ Sidebar │  Main Content Area          │
+│ │  Menu   │  ┌─────────────────────┐   │
+│ │         │  │ Dashboard Card      │   │
+│ │ • Home  │  │ - Chart            │   │
+│ │ • Data  │  │ - Metrics          │   │
+│ └─────────┘  └─────────────────────┘   │
+└─────────────────────────────────────────┘
+```
+
+#### 4.3. `ui-components.md`
+
+Specs técnicas de componentes Fluent UI/MudBlazor:
+- Componente a usar (FluentButton, MudDataGrid, etc.)
+- Props e configurações
+- Eventos e bindings
+- Validações e estados
+
+Exemplo:
+```markdown
+### DashboardCard Component
+
+**Library:** FluentCard
+**Props:**
+- Title: string
+- Subtitle: string (optional)
+- Loading: bool
+
+**Events:**
+- OnRefresh: EventCallback
+
+**Variants:**
+- Default (outline)
+- Filled (accent color)
+- Error (danger color)
+```
+
+#### 4.4. `ui-flows.md`
+
+Fluxos de usuário completos:
+- User stories
+- Diagramas de fluxo (texto/ASCII)
+- Edge cases (o que acontece se...?)
+- Validações e feedback
+
+Exemplo:
+```
+## Fluxo: Adicionar Item
+
+1. User clica "Adicionar Item"
+2. Modal abre com form
+   - Loading: Skeleton placeholders
+   - Error: Toast notification
+3. User preenche campos
+   - Validação em tempo real
+   - Campos required marcados com *
+4. User clica "Salvar"
+   - Success: Modal fecha + toast "Item adicionado"
+   - Error: Modal permanece + mensagem de erro destacada
+```
+
+### Passo 5: Validar Acessibilidade e Responsividade
+
+Documente nos arquivos UI:
+- **WCAG 2.1 Level AA** compliance
+  - Contraste de cores adequado
+  - Labels acessíveis para screen readers
+  - Navegação por teclado
+- **Responsive breakpoints**
+  - Desktop (>1200px)
+  - Tablet (768px - 1199px)
+  - Mobile (<768px)
+
+### Passo 6: Atualizar State
+
+```bash
+# Marcar fase como uiux-design
+node bin/state-manager.js set {feature-name} phase uiux-design
+
+# Marcar outputs criados
+node bin/state-manager.js mark-output {feature-name} ui-design-system
+node bin/state-manager.js mark-output {feature-name} ui-mockups
+node bin/state-manager.js mark-output {feature-name} ui-components
+node bin/state-manager.js mark-output {feature-name} ui-flows
+```
+
+## Outputs Gerados
+
+- `.morph/project/outputs/{feature}/ui-design-system.md`
+- `.morph/project/outputs/{feature}/ui-mockups.md`
+- `.morph/project/outputs/{feature}/ui-components.md`
+- `.morph/project/outputs/{feature}/ui-flows.md`
+- `.morph/project/outputs/{feature}/decisions.md` (atualizado com ADR UI library)
+
+## ⛔ PAUSA OBRIGATÓRIA
+
+Apresente ao usuário 3 ações sugeridas:
+
+1. ✅ **Aprovar UI/UX e prosseguir para design técnico**
+   Continuar para `/morph-design` (FASE 2)
+
+2. 🎨 **Ajustar wireframes/componentes de telas específicas**
+   Revisar mockups ou adicionar mais detalhes
+
+3. 🔄 **Revisar biblioteca UI escolhida (Fluent UI ↔ MudBlazor)**
+   Mudar decisão se justificado
+
+## Critérios de Avanço
+
+- [x] Input do usuário coletado (layout, referências)
+- [x] Biblioteca UI escolhida e justificada (ADR)
+- [x] 4 deliverables criados (design-system, mockups, components, flows)
+- [x] Acessibilidade WCAG 2.1 documentada
+- [x] Responsividade especificada
+- [x] State atualizado
+- [x] Usuário aprovou UI/UX
+
+---
+
+**Feature:** $ARGUMENTS