rbin-task-flow 1.0.0

package/.claude/settings.json

@@ -0,0 +1,3 @@
+{
+  "model": "claude-sonnet-4-5-20250929"
+}

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(chmod:*)",
+      "Bash(npm install)"
+    ]
+  }
+}

package/.cursor/rules/code_comments.mdc

@@ -0,0 +1,138 @@
+---
+description: Regras sobre comentários em código - proibição de comentários explicativos, uso de dev-logs para documentação, e padrão para comentários de separação
+globs: **/*
+alwaysApply: true
+---
+
+- **Proibição de Comentários Explicativos:**
+  - **❌ NUNCA adicionar** comentários que explicam o que o código faz
+  - **❌ NUNCA adicionar** comentários como "// This function does X" ou "// Check if user exists"
+  - **❌ NUNCA adicionar** comentários inline explicando lógica de negócio
+  - **✅ O código deve ser auto-explicativo** através de nomes claros de variáveis, funções e classes
+
+- **Documentação em dev-logs:**
+  - **✅ Quando precisar explicar algo complexo**, criar um arquivo em `dev-logs/` na raiz do projeto
+  - **✅ Criar a pasta `dev-logs/`** se ela não existir
+  - **✅ Usar arquivos markdown** (`.md`) para documentação técnica
+  - **✅ Incluir contexto**, decisões de design, e explicações detalhadas nos arquivos de dev-logs
+
+- **Estrutura de dev-logs:**
+  ```
+  projeto/
+  └── dev-logs/
+      ├── architecture-decisions.md
+      ├── complex-algorithms.md
+      ├── integration-notes.md
+      └── ...
+  ```
+
+- **Quando Criar dev-logs:**
+  - Algoritmos complexos que precisam de explicação detalhada
+  - Decisões de arquitetura importantes
+  - Integrações com APIs externas complexas
+  - Workarounds ou hacks necessários
+  - Contexto histórico importante
+  - Padrões não óbvios do projeto
+
+- **Formato dos Arquivos dev-logs:**
+  ```markdown
+  # Título do Tópico
+  
+  ## Contexto
+  Explicação do contexto e por que isso é necessário...
+  
+  ## Implementação
+  Detalhes da implementação...
+  
+  ## Referências
+  - Link para documentação
+  - Issue relacionada
+  ```
+
+- **Comentários de Separação Permitidos:**
+  - **✅ PERMITIDO**: Comentários que organizam e separam blocos de código
+  - **✅ SEMPRE usar** o padrão exato de separação:
+    ```typescript
+    // ────────────────────────────────
+    // Prisma Types
+    // ────────────────────────────────
+    ```
+  - **✅ Usar** para separar seções lógicas do código
+  - **✅ Usar** para organizar imports, tipos, constantes, etc.
+
+- **Padrão de Comentário de Separação:**
+  ```typescript
+  // ────────────────────────────────
+  // Seção ou Título
+  // ────────────────────────────────
+  ```
+  
+  **Características:**
+  - Linha de traços (`─`) com exatamente 31 caracteres
+  - Título centralizado entre as linhas de separação
+  - Sempre usar `//` para comentários de linha
+  - **Sem linhas em branco** entre as linhas de separação e o título
+
+- **Exemplos de Uso Correto:**
+  
+  **✅ DO: Comentário de separação**
+  ```typescript
+  // ────────────────────────────────
+  // Type Definitions
+  // ────────────────────────────────
+  
+  export type User = {
+    id: string;
+    name: string;
+  };
+  
+  // ────────────────────────────────
+  // API Functions
+  // ────────────────────────────────
+  
+  export async function fetchUser(id: string): Promise<User> {
+    // código aqui
+  }
+  ```
+  
+  **❌ DON'T: Comentários explicativos**
+  ```typescript
+  // ❌ DON'T: This function fetches a user from the database
+  export async function fetchUser(id: string): Promise<User> {
+    // ❌ DON'T: Check if user exists
+    const user = await db.user.findUnique({ where: { id } });
+    // ❌ DON'T: Return user or throw error
+    if (!user) throw new Error('User not found');
+    return user;
+  }
+  ```
+  
+  **✅ DO: Código auto-explicativo + dev-logs se necessário**
+  ```typescript
+  export async function fetchUserById(id: string): Promise<User> {
+    const user = await db.user.findUnique({ where: { id } });
+    if (!user) throw new UserNotFoundError(id);
+    return user;
+  }
+  ```
+  
+  Se a lógica for complexa, criar `dev-logs/user-fetching.md` com explicações.
+
+- **Criação Automática de dev-logs:**
+  - **Sempre verificar** se `dev-logs/` existe antes de criar arquivo
+  - **Criar a pasta** se não existir: `mkdir -p dev-logs`
+  - **Usar nomes descritivos** para os arquivos: `kebab-case.md`
+  - **Incluir data** no conteúdo do arquivo quando relevante
+
+- **Exceções e Casos Especiais:**
+  - **NENHUMA EXCEÇÃO** para comentários explicativos no código
+  - Comentários de separação **sempre** seguem o padrão exato
+  - Documentação complexa **sempre** vai para `dev-logs/`
+
+- **Integração com Outras Regras:**
+  - [cursor_rules.mdc](mdc:.cursor/rules/cursor_rules.mdc) - Formatação de regras
+  - [self_improve.mdc](mdc:.cursor/rules/self_improve.mdc) - Melhoria contínua
+  - [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) - Commits podem referenciar dev-logs
+
+- **Princípio Fundamental:**
+  > **O código deve ser auto-explicativo. Se algo precisa de explicação, documente em dev-logs/, não no código. Use comentários apenas para organização visual seguindo o padrão exato.**

package/.cursor/rules/commit_practices.mdc

@@ -0,0 +1,141 @@
+---
+description: Práticas de commit após conclusão de tarefas e subtarefas, incluindo sugestões automáticas de mensagens
+globs: **/*
+alwaysApply: true
+---
+
+- **Notificação e Sugestão de Commit Após Tarefas:**
+  - **Sempre avisar o usuário** quando uma task ou subtask for marcada como `done`
+  - **Sugerir uma mensagem de commit** baseada nas mudanças realizadas
+  - **Incluir contexto** da task/subtask na sugestão de commit
+  - **CRÍTICO: NUNCA executar comandos git** - apenas sugerir, o usuário executa
+
+- **Quando Aplicar:**
+  - Após `set_task_status` com status `done` para qualquer task ou subtask
+  - Após implementação completa de uma subtask
+  - Após conclusão de uma task pai (quando todas subtasks estiverem done)
+
+- **Formato da Sugestão de Commit:**
+  ```bash
+  # ✅ DO: Formato recomendado
+  git commit -m "feat(module): Descrição curta da mudança
+  
+  - Detalhes da implementação
+  - Task/Subtask ID: X.Y
+  - Mudanças principais realizadas"
+  
+  # Exemplo real:
+  git commit -m "feat(auth): Implement user login validation
+  
+  - Add email format validation
+  - Add password strength checks
+  - Task ID: 3.2"
+  ```
+
+- **Processo de Sugestão:**
+  1. **Analisar mudanças**: Usar `git status` e `git diff` para identificar arquivos modificados (apenas leitura, nunca modificar)
+  2. **Extrair contexto da task**: Incluir ID da task/subtask e título/descrição
+  3. **Gerar mensagem**: Criar mensagem seguindo conventional commits
+  4. **Apresentar ao usuário**: Mostrar sugestão formatada e pronta para uso
+  5. **NUNCA executar**: Apenas sugerir, o usuário decide quando e como fazer o commit
+
+- **Tipos de Commit (Conventional Commits):**
+  - `feat`: Nova funcionalidade (task completa)
+  - `fix`: Correção de bug
+  - `refactor`: Refatoração sem mudança de comportamento
+  - `docs`: Mudanças em documentação
+  - `style`: Formatação, ponto e vírgula, etc (sem mudança de código)
+  - `test`: Adição ou correção de testes
+  - `chore`: Mudanças em build, dependências, etc
+
+- **Estrutura da Mensagem Sugerida:**
+  ```bash
+  <tipo>(<escopo>): <descrição curta>
+  
+  <corpo opcional com detalhes>
+  - Task/Subtask: <ID>
+  - Arquivos modificados: <lista resumida>
+  ```
+
+- **Exemplos de Sugestões:**
+  
+  **Para subtask de implementação:**
+  ```bash
+  git commit -m "feat(api): Add user authentication endpoint
+  
+  - Implement POST /api/auth/login
+  - Add JWT token generation
+  - Add input validation middleware
+  - Subtask ID: 5.3"
+  ```
+  
+  **Para task completa:**
+  ```bash
+  git commit -m "feat(dashboard): Complete user analytics dashboard
+  
+  - Add real-time metrics display
+  - Implement chart visualizations
+  - Add data export functionality
+  - Task ID: 7"
+  ```
+  
+  **Para correção:**
+  ```bash
+  git commit -m "fix(auth): Resolve token expiration issue
+  
+  - Fix JWT refresh logic
+  - Update token validation
+  - Subtask ID: 8.1"
+  ```
+
+- **Comandos Úteis para Análise:**
+  - `git status --short` - Lista arquivos modificados de forma compacta
+  - `git diff --stat` - Estatísticas de mudanças
+  - `git diff --name-only` - Apenas nomes dos arquivos modificados
+  - `git log --oneline -5` - Últimos commits para contexto
+
+- **Quando NÃO Sugerir Commit:**
+  - ❌ DON'T: Se não houver mudanças no git (nenhum arquivo modificado)
+  - ❌ DON'T: Se o usuário já fez commit recentemente (últimos 5 minutos)
+  - ❌ DON'T: Se houver conflitos de merge não resolvidos
+  - ❌ DON'T: Se o repositório não for um git repo
+
+- **Apresentação da Sugestão:**
+  - **Sempre notificar o usuário** quando uma task/subtask for concluída com mensagem clara e emoji ✅
+  - **Mostrar sugestão formatada** pronta para copiar/colar
+  - **Incluir estatísticas** das mudanças (arquivos modificados, linhas adicionadas/removidas)
+  
+  **Exemplo de apresentação:**
+  ```markdown
+  ✅ Task 3.2 concluída!
+  
+  📝 Sugestão de commit:
+  ```bash
+  git commit -m "feat(module): Descrição da mudança
+  
+  - Detalhe 1
+  - Detalhe 2
+  - Task ID: 3.2"
+  ```
+  
+  📊 Mudanças detectadas:
+  - 3 arquivos modificados
+  - 45 linhas adicionadas, 12 removidas
+  ```
+
+- **Integração com RBIN Task Flow:**
+  - Após marcar uma task como concluída, automaticamente:
+    1. Verificar se há mudanças no git
+    2. Analisar arquivos modificados
+    3. Gerar sugestão de commit baseada na task
+    4. Apresentar ao usuário de forma clara
+
+- **Controle Git:**
+  - **NUNCA executar comandos git** - apenas sugerir
+  - Seguir [git_control.mdc](mdc:.cursor/rules/git_control.mdc) para controle total do usuário sobre git
+  - Apresentar sugestões prontas para o usuário copiar e executar
+
+- **Referências:**
+  - Seguir padrões de [Conventional Commits](https://www.conventionalcommits.org/)
+  - Integrar com workflow do RBIN Task Flow
+  - Controle git: [git_control.mdc](mdc:.cursor/rules/git_control.mdc)

package/.cursor/rules/cursor_rules.mdc

@@ -0,0 +1,53 @@
+---
+description: Guidelines for creating and maintaining Cursor rules to ensure consistency and effectiveness.
+globs: .cursor/rules/*.mdc
+alwaysApply: true
+---
+
+- **Required Rule Structure:**
+  ```markdown
+  ---
+  description: Clear, one-line description of what the rule enforces
+  globs: path/to/files/*.ext, other/path/**/*
+  alwaysApply: boolean
+  ---
+
+  - **Main Points in Bold**
+    - Sub-points with details
+    - Examples and explanations
+  ```
+
+- **File References:**
+  - Use `[filename](mdc:path/to/file)` ([filename](mdc:filename)) to reference files
+  - Example: [prisma.mdc](mdc:.cursor/rules/prisma.mdc) for rule references
+  - Example: [schema.prisma](mdc:prisma/schema.prisma) for code references
+
+- **Code Examples:**
+  - Use language-specific code blocks
+  ```typescript
+  // ✅ DO: Show good examples
+  const goodExample = true;
+  
+  // ❌ DON'T: Show anti-patterns
+  const badExample = false;
+  ```
+
+- **Rule Content Guidelines:**
+  - Start with high-level overview
+  - Include specific, actionable requirements
+  - Show examples of correct implementation
+  - Reference existing code when possible
+  - Keep rules DRY by referencing other rules
+
+- **Rule Maintenance:**
+  - Update rules when new patterns emerge
+  - Add examples from actual codebase
+  - Remove outdated patterns
+  - Cross-reference related rules
+
+- **Best Practices:**
+  - Use bullet points for clarity
+  - Keep descriptions concise
+  - Include both DO and DON'T examples
+  - Reference actual code over theoretical examples
+  - Use consistent formatting across rules 

package/.cursor/rules/git_control.mdc

@@ -0,0 +1,88 @@
+---
+description: Controle total do usuário sobre comandos Git - o AI nunca executa comandos git, mas pode executar qualquer outro comando sem perguntar
+globs: **/*
+alwaysApply: true
+---
+
+- **Permissão Geral de Comandos:**
+  - **✅ PODE executar** qualquer comando do sistema sem perguntar
+  - **✅ PODE executar** npm, yarn, pnpm, docker, etc sem confirmação
+  - **✅ PODE executar** scripts, testes, linters, formatters sem perguntar
+  - **✅ NÃO precisa perguntar** antes de executar comandos simples ou comuns
+  - **❌ ÚNICA EXCEÇÃO**: Comandos `git` que modificam o repositório
+
+- **Comandos de Leitura - Execução Automática:**
+  - **✅ SEMPRE executar sem perguntar** comandos que apenas leem informações:
+    - `cat`, `head`, `tail`, `less`, `more` - Visualização de arquivos
+    - `grep`, `find`, `ls`, `tree` - Busca e listagem
+    - `wc`, `stat`, `file` - Informações sobre arquivos
+    - `read_file` (ferramenta) - Leitura de arquivos
+    - Qualquer comando que **não modifica** arquivos ou sistema
+  - **✅ NUNCA perguntar** antes de executar comandos de leitura
+  - **✅ Executar imediatamente** sem esperar confirmação do usuário
+
+- **Proibição Absoluta de Executar Comandos Git:**
+  - **❌ NUNCA executar** comandos `git` automaticamente
+  - **❌ NUNCA fazer** `git add`, `git commit`, `git push`, `git pull`, `git merge`, etc
+  - **❌ NUNCA modificar** o estado do repositório git
+  - **✅ APENAS sugerir** comandos git quando apropriado
+  - **✅ APENAS ler** informações do git (git status, git diff, git log) para análise
+
+- **Comandos Git Permitidos (Apenas Leitura):**
+  - ✅ `git status` - Para verificar estado do repositório
+  - ✅ `git diff` - Para analisar mudanças
+  - ✅ `git log` - Para ver histórico
+  - ✅ `git show` - Para ver detalhes de commits
+  - ✅ `git branch` - Para listar branches (sem criar/modificar)
+  - ✅ Qualquer comando git que **apenas lê** informações
+
+- **Comandos Git Proibidos (Nunca Executar):**
+  - ❌ `git add` - O usuário adiciona arquivos
+  - ❌ `git commit` - O usuário faz commits
+  - ❌ `git push` - O usuário faz push
+  - ❌ `git pull` - O usuário faz pull
+  - ❌ `git merge` - O usuário faz merge
+  - ❌ `git checkout` - O usuário muda branches
+  - ❌ `git branch -d` ou `-D` - O usuário deleta branches
+  - ❌ `git reset` - O usuário faz reset
+  - ❌ `git rebase` - O usuário faz rebase
+  - ❌ `git tag` - O usuário cria tags
+  - ❌ Qualquer comando que **modifique** o repositório
+
+- **Quando Sugerir Comandos Git:**
+  - ✅ Após conclusão de task/subtask - sugerir mensagem de commit
+  - ✅ Quando há mudanças não commitadas - sugerir commit
+  - ✅ Quando há conflitos - sugerir resolução (mas não executar)
+  - ✅ Quando precisa atualizar - sugerir pull (mas não executar)
+  - ✅ Sempre apresentar como **sugestão**, nunca executar
+
+- **Formato de Sugestões:**
+  ```markdown
+  ✅ Task concluída!
+
+  📝 Sugestão de commit (você executa):
+  ```bash
+  git add .
+  git commit -m "feat(module): Descrição"
+  ```
+  ```
+
+  **NUNCA fazer:**
+  ```bash
+  # ❌ DON'T: Executar automaticamente
+  git add .
+  git commit -m "..."
+  ```
+
+- **Exceções e Casos Especiais:**
+  - **NENHUMA EXCEÇÃO para git**: Esta regra é absoluta para comandos git
+  - **Para comandos não-git**: Execute diretamente sem perguntar
+  - **Para comandos git**: Mesmo que o usuário peça explicitamente, **sempre sugerir** ao invés de executar
+  - Se houver dúvida sobre um comando ser git ou não, verificar se começa com `git` antes de executar
+
+- **Integração com Outras Regras:**
+  - [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) - Sugerir commits, nunca executar
+  - Workflow do RBIN Task Flow não deve incluir execução automática de git
+
+- **Princípio Fundamental:**
+  > **O usuário tem controle total sobre o repositório Git. O AI pode executar qualquer comando do sistema sem perguntar, EXCETO comandos git. Para git, apenas sugere, analisa e informa. Nunca modifica o estado do git.**

package/.cursor/rules/self_improve.mdc

@@ -0,0 +1,72 @@
+---
+description: Guidelines for continuously improving Cursor rules based on emerging code patterns and best practices.
+globs: **/*
+alwaysApply: true
+---
+
+- **Rule Improvement Triggers:**
+  - New code patterns not covered by existing rules
+  - Repeated similar implementations across files
+  - Common error patterns that could be prevented
+  - New libraries or tools being used consistently
+  - Emerging best practices in the codebase
+
+- **Analysis Process:**
+  - Compare new code with existing rules
+  - Identify patterns that should be standardized
+  - Look for references to external documentation
+  - Check for consistent error handling patterns
+  - Monitor test patterns and coverage
+
+- **Rule Updates:**
+  - **Add New Rules When:**
+    - A new technology/pattern is used in 3+ files
+    - Common bugs could be prevented by a rule
+    - Code reviews repeatedly mention the same feedback
+    - New security or performance patterns emerge
+
+  - **Modify Existing Rules When:**
+    - Better examples exist in the codebase
+    - Additional edge cases are discovered
+    - Related rules have been updated
+    - Implementation details have changed
+
+- **Example Pattern Recognition:**
+  ```typescript
+  // If you see repeated patterns like:
+  const data = await prisma.user.findMany({
+    select: { id: true, email: true },
+    where: { status: 'ACTIVE' }
+  });
+  
+  // Consider adding to [prisma.mdc](mdc:.cursor/rules/prisma.mdc):
+  // - Standard select fields
+  // - Common where conditions
+  // - Performance optimization patterns
+  ```
+
+- **Rule Quality Checks:**
+  - Rules should be actionable and specific
+  - Examples should come from actual code
+  - References should be up to date
+  - Patterns should be consistently enforced
+
+- **Continuous Improvement:**
+  - Monitor code review comments
+  - Track common development questions
+  - Update rules after major refactors
+  - Add links to relevant documentation
+  - Cross-reference related rules
+
+- **Rule Deprecation:**
+  - Mark outdated patterns as deprecated
+  - Remove rules that no longer apply
+  - Update references to deprecated rules
+  - Document migration paths for old patterns
+
+- **Documentation Updates:**
+  - Keep examples synchronized with code
+  - Update references to external docs
+  - Maintain links between related rules
+  - Document breaking changes
+Follow [cursor_rules.mdc](mdc:.cursor/rules/cursor_rules.mdc) for proper rule formatting and structure.