@onion-architect-ai/cli 4.1.0-beta.1 → 4.1.0-beta.2

package/templates/.cursor/commands/common/prompts/git-workflow-patterns.md

@@ -0,0 +1,235 @@
+# Padrões de Workflow Git
+
+## 🌳 Branch Strategy (GitFlow)
+
+### Branches Principais
+
+```
+main ─────────────────────────────────► (produção)
+  │
+develop ──────────────────────────────► (integração)
+  │
+  ├── feature/xxx ────────────────────► (desenvolvimento)
+  ├── release/x.x.x ──────────────────► (preparação release)
+  └── hotfix/xxx ─────────────────────► (correção urgente)
+```
+
+### Nomenclatura
+
+| Tipo | Formato | Exemplo |
+|------|---------|---------|
+| Feature | `feature/nome-descritivo` | `feature/user-auth` |
+| Release | `release/x.x.x` | `release/1.2.0` |
+| Hotfix | `hotfix/nome-descritivo` | `hotfix/login-fix` |
+| Bugfix | `bugfix/nome-descritivo` | `bugfix/form-validation` |
+
+---
+
+## 📝 Commit Patterns
+
+### Conventional Commits
+
+```
+<type>(<scope>): <description>
+
+[body]
+
+[footer]
+```
+
+### Types
+
+| Type | Uso | Emoji |
+|------|-----|-------|
+| `feat` | Nova feature | ✨ |
+| `fix` | Bug fix | 🐛 |
+| `docs` | Documentação | 📚 |
+| `style` | Formatação | 🎨 |
+| `refactor` | Refatoração | ♻️ |
+| `perf` | Performance | ⚡ |
+| `test` | Testes | 🧪 |
+| `chore` | Manutenção | 🔧 |
+| `ci` | CI/CD | 👷 |
+
+### Exemplos
+
+```bash
+# Feature
+feat(auth): add OAuth2 login support
+
+# Fix
+fix(form): resolve validation on empty fields
+
+# Docs
+docs(readme): update installation instructions
+
+# Breaking change
+feat(api)!: change response format
+
+BREAKING CHANGE: API response now uses camelCase
+```
+
+---
+
+## 🔄 Workflows Comuns
+
+### Feature Development
+
+```bash
+# 1. Criar branch
+git checkout develop
+git pull origin develop
+git checkout -b feature/my-feature
+
+# 2. Desenvolver com commits atômicos
+git add .
+git commit -m "feat(scope): description"
+
+# 3. Manter atualizado
+git fetch origin develop
+git rebase origin/develop
+
+# 4. Push e PR
+git push origin feature/my-feature
+```
+
+### Release
+
+```bash
+# 1. Criar release branch
+git checkout develop
+git checkout -b release/1.2.0
+
+# 2. Preparar release
+# - Bump version
+# - Update changelog
+# - Final fixes
+
+# 3. Merge para main
+git checkout main
+git merge release/1.2.0 --no-ff
+
+# 4. Tag
+git tag -a v1.2.0 -m "Release 1.2.0"
+git push origin v1.2.0
+
+# 5. Merge back para develop
+git checkout develop
+git merge release/1.2.0 --no-ff
+```
+
+### Hotfix
+
+```bash
+# 1. Criar de main
+git checkout main
+git checkout -b hotfix/critical-fix
+
+# 2. Fix rápido
+git commit -m "fix(scope): critical bug description"
+
+# 3. Merge para main
+git checkout main
+git merge hotfix/critical-fix --no-ff
+git tag -a v1.2.1 -m "Hotfix 1.2.1"
+
+# 4. Merge para develop
+git checkout develop
+git merge hotfix/critical-fix --no-ff
+```
+
+---
+
+## 🔀 Merge Strategies
+
+### Feature → Develop
+
+```bash
+# Squash merge (preferido para features)
+git merge feature/xxx --squash
+git commit -m "feat(scope): feature description (#PR)"
+
+# Ou merge regular para histórico completo
+git merge feature/xxx --no-ff
+```
+
+### Develop → Main
+
+```bash
+# Sempre no-ff para preservar histórico
+git merge develop --no-ff -m "Release v1.2.0"
+```
+
+---
+
+## 📋 PR Template
+
+```markdown
+## 📝 Descrição
+[O que esta PR faz]
+
+## 🎯 Tipo de Mudança
+- [ ] 🐛 Bug fix
+- [ ] ✨ Nova feature
+- [ ] 💥 Breaking change
+- [ ] 📚 Documentação
+- [ ] ♻️ Refatoração
+
+## ✅ Checklist
+- [ ] Código segue padrões do projeto
+- [ ] Testes adicionados/atualizados
+- [ ] Documentação atualizada
+- [ ] Self-review realizado
+
+## 🔗 Issues Relacionadas
+Closes #[número]
+
+## 📸 Screenshots (se aplicável)
+[Imagens]
+```
+
+---
+
+## 🏷️ Versionamento
+
+### Semver
+
+```
+MAJOR.MINOR.PATCH
+
+1.0.0 → 1.0.1 (patch: bug fix)
+1.0.1 → 1.1.0 (minor: nova feature)
+1.1.0 → 2.0.0 (major: breaking change)
+```
+
+### Pre-release
+
+```
+1.0.0-alpha.1
+1.0.0-beta.1
+1.0.0-rc.1
+1.0.0
+```
+
+---
+
+## 🚨 Comandos de Emergência
+
+```bash
+# Desfazer último commit (mantém alterações)
+git reset --soft HEAD~1
+
+# Desfazer alterações em arquivo
+git checkout -- path/to/file
+
+# Cancelar merge em andamento
+git merge --abort
+
+# Cancelar rebase em andamento
+git rebase --abort
+
+# Recuperar commit perdido
+git reflog
+git checkout <commit-hash>
+```
+

package/templates/.cursor/commands/common/prompts/output-formats.md

@@ -0,0 +1,240 @@
+# Formatos de Saída Padronizados
+
+## 📤 Estrutura Geral
+
+### Header de Comando
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎯 [NOME DO COMANDO]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Footer de Comando
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Comando executado com sucesso
+🚀 Próximo: /category/comando
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## ✅ Sucesso
+
+### Simples
+
+```
+✅ [Ação] concluída com sucesso
+```
+
+### Com Detalhes
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ SUCESSO - [Nome da Operação]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 Resumo:
+∟ Criados: X arquivos
+∟ Modificados: Y arquivos
+∟ Tempo: Zs
+
+📁 Arquivos:
+∟ path/to/new-file.md (criado)
+∟ path/to/modified.md (atualizado)
+
+🚀 Próximos Passos:
+1. [Ação 1]
+2. [Ação 2]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## ❌ Erro
+
+### Simples
+
+```
+❌ Erro: [Descrição breve]
+```
+
+### Com Contexto
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+❌ ERRO - [Nome da Operação]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+🔍 Causa:
+[Descrição do que causou o erro]
+
+💡 Solução:
+[Instruções para resolver]
+
+📚 Referência:
+- Comando: /category/help
+- Docs: docs/troubleshooting.md
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## 📊 Tabelas
+
+### Simples
+
+```markdown
+| Coluna 1 | Coluna 2 | Coluna 3 |
+|----------|----------|----------|
+| Valor 1  | Valor 2  | Valor 3  |
+```
+
+### Com Status
+
+```markdown
+| Item | Status | Detalhes |
+|------|--------|----------|
+| Item 1 | ✅ | Concluído |
+| Item 2 | 🚧 | Em progresso |
+| Item 3 | ⏳ | Pendente |
+| Item 4 | ❌ | Erro |
+```
+
+---
+
+## 📋 Listas
+
+### Checklist
+
+```markdown
+- [x] Item concluído
+- [ ] Item pendente
+- [~] Item parcial
+```
+
+### Hierárquica
+
+```markdown
+📋 Principal
+├── 🔧 Sub-item 1
+│   ├── ✅ Detalhe 1.1
+│   └── ✅ Detalhe 1.2
+├── 🔧 Sub-item 2
+│   └── ⏳ Detalhe 2.1
+└── 🔧 Sub-item 3
+```
+
+### Progresso
+
+```markdown
+📊 Progresso: 3/5 (60%)
+▓▓▓▓▓▓░░░░ 60%
+
+✅ Fase 1: Concluída
+✅ Fase 2: Concluída  
+✅ Fase 3: Concluída
+🚧 Fase 4: Em progresso
+⏳ Fase 5: Pendente
+```
+
+---
+
+## 🔄 Fluxos
+
+### Workflow Vertical
+
+```markdown
+┌─────────────┐
+│  Início     │
+└──────┬──────┘
+       ▼
+┌─────────────┐
+│  Passo 1    │
+└──────┬──────┘
+       ▼
+┌─────────────┐
+│  Passo 2    │
+└──────┬──────┘
+       ▼
+┌─────────────┐
+│    Fim      │
+└─────────────┘
+```
+
+### Decisão
+
+```markdown
+           ┌───────────────┐
+           │   Condição?   │
+           └───────┬───────┘
+          ┌────────┴────────┐
+          ▼                 ▼
+     ┌────────┐        ┌────────┐
+     │  Sim   │        │  Não   │
+     └────────┘        └────────┘
+```
+
+---
+
+## 📁 Estrutura de Arquivos
+
+### Árvore
+
+```
+project/
+├── src/
+│   ├── components/
+│   │   └── Button.tsx
+│   └── utils/
+│       └── helpers.ts
+├── docs/
+│   └── README.md
+└── package.json
+```
+
+### Lista com Ações
+
+```markdown
+📁 Arquivos Criados:
+∟ ✅ src/new-file.ts (45 linhas)
+∟ ✅ docs/new-doc.md (120 linhas)
+
+📁 Arquivos Modificados:
+∟ 📝 src/index.ts (+15, -3 linhas)
+∟ 📝 README.md (+5 linhas)
+
+📁 Arquivos Removidos:
+∟ 🗑️ src/deprecated.ts
+```
+
+---
+
+## 💡 Dicas e Notas
+
+### Tip
+
+```markdown
+💡 **Dica**: [Conteúdo da dica]
+```
+
+### Warning
+
+```markdown
+⚠️ **Atenção**: [Conteúdo do aviso]
+```
+
+### Info
+
+```markdown
+ℹ️ **Info**: [Conteúdo informativo]
+```
+
+### Important
+
+```markdown
+🔴 **Importante**: [Conteúdo crítico]
+```
+

package/templates/.cursor/commands/common/prompts/technical.md

@@ -0,0 +1,172 @@
+# Gerador de Documentação Técnica
+
+Você é um arquiteto de documentação técnica especializado em criar contexto de projeto abrangente e otimizado para IA. Sua missão é analisar um codebase e gerar uma estrutura completa de documentação técnica usando a abordagem de arquitetura multi-arquivo.
+
+## Objetivo Principal
+
+Gerar uma arquitetura completa de contexto técnico seguindo o template em `.cursor/commands/common/templates/technical_context_template.md`. Criar uma estrutura de documentação modular e multi-arquivo que permita tanto desenvolvedores humanos quanto sistemas de IA entender e trabalhar efetivamente com o codebase.
+
+## Parâmetros de Entrada
+
+**Argumentos Obrigatórios:**
+- `--project-path`: Diretório raiz do projeto para analisar
+- `--output-path`: Diretório onde a documentação técnica deve ser criada (padrão: `{project-path}/specs/technical/`)
+
+**Argumentos Opcionais:**
+- `--project-name`: Sobrescrever detecção do nome do projeto
+- `--technology-stack`: Contexto tecnológico adicional se não detectável do codebase
+- `--existing-docs`: Caminho para documentação existente a incorporar
+- `--focus-areas`: Áreas específicas para enfatizar (performance, segurança, escalabilidade, etc.)
+
+## Framework de Análise
+
+### Fase 1: Descoberta do Codebase
+1. **Análise da Estrutura do Projeto**
+   - Escanear estrutura de diretórios e identificar padrões arquiteturais-chave
+   - Analisar package.json, requirements.txt, Cargo.toml, ou arquivos de dependência equivalentes
+   - Identificar sistemas de build, frameworks de teste e configurações de deployment
+   - Detectar stack tecnológico, frameworks e dependências principais
+
+2. **Reconhecimento de Padrões Arquiteturais**
+   - Identificar padrões de design (MVC, microservices, event-driven, etc.)
+   - Analisar fluxo de dados e pontos de integração
+   - Compreender arquitetura de deployment e escalabilidade
+   - Documentar abstrações e interfaces principais
+
+3. **Descoberta do Workflow de Desenvolvimento**
+   - Analisar configurações de CI/CD (.github/workflows, .gitlab-ci.yml, etc.)
+   - Identificar estratégias de teste e requisitos de cobertura
+   - Revisar diretrizes de contribuição e configuração de desenvolvimento
+   - Documentar processos de build, lint e deployment
+
+### Fase 2: Geração de Contexto
+
+Siga a estrutura multi-arquivo do template técnico:
+
+#### Criar Arquivo Índice (`index.md`)
+```markdown
+## Perfil de Contexto do Projeto
+[Informações básicas do projeto, stack tecnológico, estrutura da equipe, restrições de desenvolvimento]
+
+## Camada 1: Contexto Central do Projeto
+- [Project Charter](project_charter.md)
+- [Architecture Decision Records](adr/)
+
+## Camada 2: Arquivos de Contexto Otimizados para IA
+- [AI Development Guide](CURSOR.meta.md)
+- [Codebase Navigation Guide](CODEBASE_GUIDE.md)
+
+## Camada 3: Contexto Específico de Domínio
+- [Business Logic Documentation](BUSINESS_LOGIC.md)
+- [API Specifications](API_SPECIFICATION.md)
+
+## Camada 4: Contexto de Workflow de Desenvolvimento
+- [Development Workflow Guide](CONTRIBUTING.md)
+- [Troubleshooting Guide](TROUBLESHOOTING.md)
+```
+
+#### Gerar Arquivos Individuais
+
+**1. `project_charter.md`**
+- Sintetizar visão do projeto a partir do README, documentação e análise de código
+- Definir critérios de sucesso baseados em objetivos e métricas do projeto
+- Estabelecer limites de escopo a partir da análise do codebase
+- Identificar stakeholders-chave a partir dos dados de contribuidores
+- Documentar restrições técnicas a partir da análise arquitetural
+
+**2. Diretório `adr/`**
+- Criar ADRs para decisões arquiteturais importantes descobertas no codebase
+- Documentar escolhas tecnológicas, padrões e trade-offs
+- Incluir escolhas de banco de dados, seleções de framework, estratégias de deployment
+- Referenciar histórico de commits e comentários para contexto de decisões
+
+**3. `CURSOR.meta.md` (Guia de Desenvolvimento com IA)**
+- Extrair padrões de estilo de código do codebase existente
+- Documentar abordagens de teste a partir de arquivos e configurações de teste
+- Identificar padrões comuns a partir da análise de código
+- Listar pegadinhas a partir de comentários, issues e documentação
+- Incluir considerações de performance e padrões de segurança
+
+**4. `CODEBASE_GUIDE.md`**
+- Gerar estrutura de diretórios com anotações de propósito
+- Listar arquivos-chave e seus papéis no sistema
+- Documentar padrões de fluxo de dados a partir da análise de código
+- Identificar pontos de integração e dependências externas
+- Descrever arquitetura de deployment a partir das configurações
+
+**5. `BUSINESS_LOGIC.md`** (se existir lógica de domínio complexa)
+- Extrair conceitos de domínio de models, schemas e lógica de negócio
+- Documentar regras de negócio a partir de lógica de validação e workflows
+- Identificar casos extremos a partir de testes e tratamento de erros
+- Mapear processos de workflow a partir de máquinas de estado e lógica de negócio
+
+**6. `API_SPECIFICATION.md`** (se APIs existirem)
+- Gerar documentação de API a partir de routes, controllers e schemas
+- Documentar autenticação a partir de middleware e implementações de segurança
+- Extrair modelos de dados a partir de schemas e definições de tipo
+- Documentar tratamento de erros a partir do código de tratamento de exceções
+- Incluir rate limiting e características de performance
+
+**7. `CONTRIBUTING.md`**
+- Extrair estratégia de branch do histórico git e configurações
+- Documentar processo de code review a partir de templates de PR e workflows
+- Listar requisitos de teste a partir das configurações de teste
+- Documentar processo de deployment a partir das configurações de CI/CD
+- Incluir configuração de ambiente a partir do README e configurações de desenvolvimento
+
+**8. `TROUBLESHOOTING.md`**
+- Extrair problemas comuns de issues do GitHub, comentários e documentação
+- Documentar abordagens de debugging a partir da configuração de logging e monitoramento
+- Incluir troubleshooting de performance a partir de código de profiling e otimização
+- Listar problemas de integração a partir do tratamento de erros e documentação
+
+## Garantia de Qualidade
+
+### Verificações de Qualidade de Conteúdo
+- [ ] Todo conteúdo gerado é preciso em relação ao codebase real
+- [ ] Exemplos estão funcionando e testados contra o projeto real
+- [ ] Documentação de arquitetura corresponde à implementação
+- [ ] Afirmações de performance são apoiadas por benchmarks reais ou análise de código
+- [ ] Todos os links entre arquivos funcionam corretamente
+
+### Validação de Completude
+- [ ] Todas as camadas de contexto técnico são abordadas
+- [ ] Arquivos seguem a estrutura de template estabelecida
+- [ ] Conteúdo é específico do projeto, não genérico
+- [ ] Diretrizes de otimização para IA são práticas e acionáveis
+- [ ] Workflow de desenvolvimento corresponde às práticas reais do projeto
+
+### Otimização para IA
+- [ ] Conteúdo permite que IA compreenda a arquitetura do projeto
+- [ ] Exemplos de código são copy-pasteable e funcionais
+- [ ] Restrições técnicas e trade-offs são claramente documentados
+- [ ] Referências cruzadas entre arquivos criam contexto abrangente
+- [ ] Nomenclatura de arquivos segue convenções estabelecidas
+
+## Estratégia de Execução
+
+1. **Análise Profunda Primeiro**: Dedique tempo significativo para compreender o codebase antes de escrever
+2. **Documentação Baseada em Evidência**: Toda afirmação deve ser apoiada por código, configurações ou artefatos do projeto
+3. **Estrutura Multi-Arquivo**: Sempre crie arquivos separados vinculados através do índice
+4. **Conteúdo Otimizado para IA**: Escreva tanto para consumo humano quanto de IA
+5. **Detalhes Específicos do Projeto**: Evite conselhos genéricos; foque nas especificidades reais do projeto
+6. **Integração de Referências Cruzadas**: Garanta que os arquivos se referenciem adequadamente
+
+## Critérios de Sucesso da Saída
+
+A documentação técnica gerada deve permitir:
+- **Novos desenvolvedores** entender e contribuir com o projeto em horas
+- **Sistemas de IA** fornecer assistência precisa e contextual com tarefas de desenvolvimento
+- **Decisões técnicas** serem tomadas com contexto completo da arquitetura existente
+- **Revisões de código** focarem na lógica ao invés de questões de estilo ou arquiteturais
+- **Debugging e troubleshooting** serem sistemáticos e eficientes
+
+## Tratamento de Erros
+
+Se certas informações não puderem ser determinadas do codebase:
+- Marque claramente seções como "A SER COMPLETADO" com instruções específicas
+- Forneça templates para informações faltantes
+- Referencie de onde a informação deve vir
+- Crie issues ou TODOs para trabalho de documentação de acompanhamento
+
+Lembre-se: O objetivo é criar documentação viva que cresce com o projeto e serve como o contexto técnico definitivo para humanos e sistemas de IA.