rbin-task-flow 1.0.0 → 1.1.0

package/.claude/settings.json

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

package/.cursor/rules/task_generation.mdc

@@ -6,22 +6,36 @@ alwaysApply: true
 
 - **Task Generation - Direct and Efficient:**
   - When user asks to "Read tasks.input.txt and generate detailed subtasks updating task status":
-    - **READ ONLY**: `.task-flow/tasks.input.txt`
+    - **READ**: `.task-flow/tasks.input.txt` (only process lines starting with `- `)
+    - **READ**: `.task-flow/screens/` directory to list available screenshots (ALWAYS check this directory)
     - **GENERATE**: Two JSON files and one markdown file with the exact structure below
     - **SAVE**: All files to `.task-flow/`
-    - **DON'T**: Read other files, check existing JSONs, explore codebase, or ask questions
+    - **DON'T**: Check existing JSONs, explore codebase, or ask questions
+
+- **Screenshot Reference System:**
+  - **AUTOMATIC**: Always check `.task-flow/screens/` directory for available screenshots (PNG, JPG files)
+  - **NO LISTING NEEDED**: Don't require screenshots to be listed in tasks.input.txt - always scan the directory
+  - **AUTOMATIC MATCHING**: Automatically match screenshots to tasks based on keywords (e.g., "login" → `login_recover_signup.png`, "dashboard" → `dashboard.png`, "paciente" → `patient.png`)
+  - **SPECIFIC REFERENCE**: If task contains `task-flow-screen nome_do_arquivo.png`, reference that specific screenshot from `.task-flow/screens/`
+  - **PATH ALWAYS**: `task-flow-screen` always references files in `.task-flow/screens/` directory
+  - **INCLUDE**: Add screenshot reference in instructions: "Referência visual: `.task-flow/screens/nome_do_arquivo.png`"
 
 - **Required Actions:**
-  1. Read `tasks.input.txt` (ignore comments, only process lines starting with `- `)
-  2. For each task line, create a task with sequential ID starting at 1
-  3. Generate 3-8 subtasks per task with:
+  1. Read `tasks.input.txt`:
+     - Process task lines (only process lines starting with `- `)
+     - Check for `task-flow-screen nome_do_arquivo.png` markers in task descriptions
+  2. **ALWAYS** list available screenshots from `.task-flow/screens/` directory (PNG, JPG files)
+  3. For each task line, create a task with sequential ID starting at 1
+  4. Generate 3-8 subtasks per task with:
      - Clear title
      - Brief description
      - Step-by-step instructions (3-5 steps)
-  4. Create `.task-flow/.internal/tasks.json` with structure below
-  5. Create `.task-flow/.internal/status.json` with all tasks/subtasks as "pending"
-  6. Create `.task-flow/tasks.status.md` with all tasks and subtasks marked as `- [ ]` (pending)
-  7. Write all three files immediately
+     - **AUTOMATIC**: Include relevant screenshot references when applicable (match by keywords)
+     - **SPECIFIC**: If task has `task-flow-screen nome_do_arquivo.png`, reference that specific screenshot from `.task-flow/screens/`
+  5. Create `.task-flow/.internal/tasks.json` with structure below
+  6. Create `.task-flow/.internal/status.json` with all tasks/subtasks as "pending"
+  7. Create `.task-flow/tasks.status.md` with all tasks and subtasks marked as `- [ ]` (pending)
+  8. Write all three files immediately
 
 - **tasks.json Structure:**
   ```json
@@ -103,12 +117,26 @@ alwaysApply: true
 
 - **Example:**
   - Input (`tasks.input.txt`): `- Create authentication system`
-  - Output: Task with ID 1, 5 subtasks (setup database, create models, implement login, add JWT, test)
+  - Screenshots available: `login_recover_signup.png`
+  - Output: Task with ID 1, 5 subtasks with screenshot references:
+    - Subtask 1: "Setup database schema" (no screenshot)
+    - Subtask 2: "Create login form" → Instructions include: "Referência visual: `.task-flow/screens/login_recover_signup.png`"
+    - Subtask 3: "Implement registration" → Instructions include screenshot reference
+    - Subtask 4: "Add JWT authentication" (no screenshot)
+    - Subtask 5: "Test authentication flow" → Instructions include screenshot reference
+  
+- **Screenshot Reference Examples:**
+  - Task: `- Sistema de autenticação do dentista` → Automatically matches and references `login_recover_signup.png` from `.task-flow/screens/`
+  - Task: `- Dashboard básico com estrutura task-flow-screen dashboard.png` → References specific `.task-flow/screens/dashboard.png`
+  - Task: `- CRUD completo de pacientes` → Automatically matches and references `patient.png` and `patient_profile.png` from `.task-flow/screens/` if available
+  - **IMPORTANT**: `task-flow-screen` always references files in `.task-flow/screens/` - no need to specify full path
 
 - **Critical Rules:**
   - ✅ Be direct: Read → Generate → Save
-  - ✅ No unnecessary file reads
-  - ✅ No exploration of codebase
+  - ✅ **ALWAYS** check `.task-flow/screens/` directory for available screenshots (automatic, no need to list in tasks.input.txt)
+  - ✅ Automatically match and reference relevant screenshots in subtask instructions based on keywords
+  - ✅ Support `task-flow-screen nome_do_arquivo.png` format - always references `.task-flow/screens/nome_do_arquivo.png`
+  - ✅ No exploration of codebase beyond screenshots directory
   - ✅ No questions - just generate
   - ✅ Use current timestamp for `createdAt`
   - ✅ All statuses start as "pending"

package/.cursor/rules/task_work.mdc

@@ -56,6 +56,8 @@ alwaysApply: true
      - Skip "done" and "in_progress" subtasks
   3. **For each subtask**:
      - Read full instructions from `tasks.json`
+     - **CHECK**: If instructions mention screenshot references (`.task-flow/screens/...`), verify screenshot exists
+     - **REFERENCE**: Use screenshots as visual reference when implementing UI-related subtasks
      - Implement following step-by-step instructions
      - Test/verify implementation
      - Update `status.json` to mark as "done"
@@ -83,6 +85,8 @@ alwaysApply: true
      - Skip "done" and "in_progress" subtasks
   4. **For each subtask** (only if dependency check passed):
      - Read full instructions from `tasks.json`
+     - **CHECK**: If instructions mention screenshot references (`.task-flow/screens/...`), verify screenshot exists
+     - **REFERENCE**: Use screenshots as visual reference when implementing UI-related subtasks
      - Implement following step-by-step instructions
      - Test/verify implementation
      - Update `status.json` to mark as "done"
@@ -196,8 +200,15 @@ alwaysApply: true
   - If file doesn't exist → create it
   - If instructions unclear → ask for clarification (but try to infer first)
 
+- **Screenshot Support:**
+  - **AUTOMATIC**: When implementing subtasks, check if instructions reference screenshots
+  - **REFERENCE**: Use screenshots from `.task-flow/screens/` as visual reference for UI implementation
+  - **MATCHING**: Match screenshot references mentioned in subtask instructions
+  - **NO NEED**: User doesn't need to explicitly mention screenshots - they're automatically considered
+
 - **Integration:**
   - Works with [task_execution.mdc](mdc:.cursor/rules/task_execution.mdc) - same workflow
+  - Follows [task_generation.mdc](mdc:.cursor/rules/task_generation.mdc) - screenshots are automatically referenced in generated subtasks
   - Follows [commit_practices.mdc](mdc:.cursor/rules/commit_practices.mdc) - suggest commit after completion
   - Respects [git_control.mdc](mdc:.cursor/rules/git_control.mdc) - never commit automatically
 

package/.task-flow/screens/example.png.txt

@@ -0,0 +1,24 @@
+# Screenshot de Exemplo
+
+Este é um arquivo placeholder. Substitua este arquivo por um screenshot real (PNG ou JPG).
+
+## Como adicionar screenshots:
+
+1. Adicione seus arquivos de imagem (.png ou .jpg) nesta pasta
+2. Use nomes descritivos em kebab-case
+3. O RBIN Task Flow automaticamente detectará e referenciará os screenshots
+
+## Exemplos de nomes:
+
+- `login_recover_signup.png`
+- `dashboard.png`
+- `patient.png`
+- `patient_profile.png`
+- `prescriptions.png`
+- `medicine.png`
+
+## Referenciar em tasks:
+
+Para referenciar um screenshot específico em uma task, use:
+`task-flow-screen: nome_do_arquivo.png`
+

package/.task-flow/tasks.input.txt

@@ -7,8 +7,16 @@
 3. Use `task-flow: sync` to generate subtasks from your tasks
 4. Use `task-flow: status` to view task progress
 
-## Tasks:
+## Screenshots:
+
+- Adicione seus screenshots na pasta `.task-flow/screens/` (PNG ou JPG)
+- O RBIN Task Flow automaticamente detecta e referencia os screenshots disponíveis ao gerar subtasks
+- Para referenciar um screenshot específico em uma task, use: `task-flow-screen nome_do_arquivo.png`
+- Exemplo: `- Criar tela de login task-flow-screen login.png`
 
-- First task
-- Second task
+## Tasks:
 
+- Criar sistema de autenticação (login, registro, recuperação de senha)
+- Implementar dashboard com métricas principais
+- CRUD completo de usuários
+- Sistema de notificações

package/README.md

@@ -9,30 +9,399 @@
 ![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)
 ![npm](https://img.shields.io/npm/v/rbin-task-flow?style=for-the-badge)
 
-**One-command setup for Claude Code, Gemini, Cursor, and RBIN Task Flow in any project**
+**Configuração com um comando para Claude Code, Gemini, Cursor e RBIN Task Flow em qualquer projeto**
+
+<div style="margin-top: 20px; margin-bottom: 20px;">
+  <a href="#português">🇧🇷 Português</a> | <a href="#english">🇬🇧 English</a>
+</div>
 
 </div>
 
 ---
 
-## Overview
+<div align="center">
 
-A centralized repository of development configurations and rules that can be instantly installed in any project. Provides complete setup for Claude Code, Gemini, Cursor IDE, and RBIN Task Flow - a simple AI-powered task management system.
+### Screenshots
 
-### Key Features
+<img src=".github/screens/1.png" alt="Screenshot 1" width="800"/>
+<img src=".github/screens/2.png" alt="Screenshot 2" width="800"/>
+<img src=".github/screens/3.png" alt="Screenshot 3" width="800"/>
 
-- **NPM Global Installation** - Install once, use everywhere with `npm install -g rbin-task-flow`
-- **Simple Task Management** - Define tasks in plain text, AI generates detailed subtasks
-- **Multiple AI Models** - Claude Code Sonnet and Gemini 3 Flash configured and ready to use
-- **Discrete .gitignore** - AI configs hidden with generic comments
-- **Zero Configuration** - Ready to use immediately
-- **RBIN Task Flow** - AI-powered task management with simple text interface
+</div>
 
-## System Requirements
+---
 
-- **Operating System:** macOS, Linux, or Windows (WSL)
-- **Tools:** Git, Bash, Node.js
-- **Required:** Claude Code CLI, Gemini API access, or Cursor IDE (with Pro subscription)
+<a id="português"></a>
+# 🇧🇷 Português
+
+## O Que É Este Projeto?
+
+RBIN Task Flow é um sistema de gerenciamento de tarefas alimentado por IA que configura automaticamente Claude Code, Gemini e Cursor IDE em qualquer projeto. Você define tarefas em texto simples e a IA gera subtarefas detalhadas e acionáveis automaticamente.
+
+**Principais benefícios:**
+- ✅ Instalação global NPM - instale uma vez, use em qualquer projeto
+- ✅ Zero configuração - pronto para usar imediatamente
+- ✅ Gerenciamento simples - escreva tarefas em texto, a IA faz o resto
+- ✅ Múltiplos modelos de IA - Claude, Gemini e Cursor configurados
+
+## Instalação
+
+### Início Rápido (NPM Global)
+
+```bash
+# 1. Instalar globalmente via npm (apenas uma vez)
+npm install -g rbin-task-flow
+
+# 2. Ir para qualquer projeto e inicializar
+cd /caminho/para/seu/projeto
+rbin-task-flow init
+
+# 3. Usar comandos da IA
+# Edite .task-flow/tasks.input.txt e use:
+# - task-flow: sync
+# - task-flow: run next X
+# - task-flow: run task X
+```
+
+**Pronto!** RBIN Task Flow agora está disponível globalmente no seu sistema.
+
+## Comandos
+
+### Comandos CLI
+
+```bash
+rbin-task-flow init          # Inicializa no projeto atual
+rbin-task-flow update        # Atualiza configurações
+rbin-task-flow version-check # Verifica atualizações de modelos
+rbin-task-flow info          # Mostra informações
+```
+
+### Comandos da IA - Por Que Usar?
+
+Após inicializar, use estes comandos na IA (Cursor/Claude/Gemini) para gerenciar tarefas automaticamente:
+
+| Comando | Por Que Usar | Feature Principal |
+|---------|--------------|-------------------|
+| `task-flow: sync` | **Sincroniza** tarefas do arquivo texto com o sistema | Mantém tudo sincronizado automaticamente - adiciona novas, remove deletadas, preserva seu progresso |
+| `task-flow: think` | **Descobre** tarefas que você esqueceu | Analisa código e sugere tarefas que faltam (testes, refatoração, documentação) |
+| `task-flow: run next X` | **Automatiza** o trabalho nas próximas subtarefas | A IA trabalha nas próximas X subtarefas sequencialmente, você só acompanha |
+| `task-flow: run task X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
+| `task-flow: status` | **Visualiza** o progresso rapidamente | Vê resumo com tasks completas, em andamento e quantas subtarefas faltam |
+| `task-flow: review` | **Garante** qualidade do trabalho | Verifica se tarefas marcadas como "done" estão realmente concluídas |
+| `task-flow: refactor` | **Melhora** código sem quebrar | Refatora código do commit atual removendo comentários e melhorando qualidade |
+
+**Fluxo típico:**
+
+```bash
+# 1. Instalar e inicializar
+npm install -g rbin-task-flow
+cd meu-projeto && rbin-task-flow init
+
+# 2. Editar tarefas em texto simples
+# Edite .task-flow/tasks.input.txt:
+# - Criar sistema de autenticação
+# - Adicionar testes
+
+# 3. Usar comandos da IA:
+# "task-flow: sync" → Gera subtarefas detalhadas automaticamente
+# "task-flow: run next 3" → IA trabalha nas próximas 3 subtarefas
+# "task-flow: status" → Vê progresso visual
+```
+
+## Visão Geral
+
+Repositório centralizado de configurações e regras de desenvolvimento que podem ser instaladas instantaneamente em qualquer projeto. Fornece configuração completa para Claude Code, Gemini, Cursor IDE e RBIN Task Flow - um sistema simples de gerenciamento de tarefas alimentado por IA.
+
+### Principais Recursos
+
+- **Instalação Global NPM** - Instale uma vez, use em qualquer lugar com `npm install -g rbin-task-flow`
+- **Gerenciamento Simples de Tarefas** - Defina tarefas em texto simples, a IA gera subtarefas detalhadas
+- **Múltiplos Modelos de IA** - Claude Code Sonnet e Gemini 3 Flash configurados e prontos para uso
+- **.gitignore Discreto** - Configurações de IA ocultas com comentários genéricos
+- **Zero Configuração** - Pronto para usar imediatamente
+- **RBIN Task Flow** - Gerenciamento de tarefas alimentado por IA com interface de texto simples
+
+## Requisitos do Sistema
+
+- **Sistema Operacional:** macOS, Linux ou Windows (WSL)
+- **Ferramentas:** Git, Bash, Node.js
+- **Necessário:** Claude Code CLI, acesso à API Gemini ou Cursor IDE (com assinatura Pro)
+
+### Alternativa: Instalação Legacy (Sem NPM)
+
+Se você preferir o método antigo sem npm:
+
+```bash
+# 1. Clonar este repositório
+git clone https://github.com/rbinoliveira/rbin-task-flow.git ~/.rbin-task-flow
+
+# 2. Instalar no seu projeto
+~/.rbin-task-flow/install.sh
+# Digite o caminho do projeto quando solicitado
+```
+
+### O Que É Instalado
+
+O script cria e configura:
+
+```
+seu-projeto/
+├── .cursor/
+│   ├── rules/                    # Todas as regras de desenvolvimento
+│   │   ├── cursor_rules.mdc
+│   │   ├── self_improve.mdc
+│   │   ├── code_comments.mdc
+│   │   ├── commit_practices.mdc
+│   │   ├── git_control.mdc
+│   │   └── task_execution.mdc
+│   └── settings.json             # Configurações do modelo Cursor
+│
+├── .claude/
+│   └── settings.json             # Configurações do Claude Code
+│
+├── .gemini/
+│   └── settings.json             # Configurações do Gemini
+│
+├── .task-flow/                   # RBIN Task Flow
+│   ├── tasks.input.txt           # Definições de tarefas em texto simples (edite isso!)
+│   ├── tasks.status.md           # ⚠️ Status das tarefas (atualizado automaticamente, NÃO EDITE)
+│   └── .internal/                # ⚠️ Arquivos internos do sistema (ignore - gerados automaticamente)
+│       ├── tasks.json            # Definições de tarefas (auto)
+│       └── status.json           # Rastreamento de status das tarefas (auto)
+│
+└── .gitignore                    # Atualizado com entradas discretas
+```
+
+## Configuração
+
+Nenhuma configuração adicional necessária! Apenas certifique-se de ter:
+- Claude Code CLI instalado, OU
+- Acesso à API Gemini configurado, OU
+- Cursor IDE com assinatura Pro ativa
+
+**Você está pronto!**
+
+### Integração com Cursor
+
+O Cursor vem pré-configurado com:
+- Claude Sonnet 4.5 Pro como modelo padrão
+- Configurações personalizadas
+- Integração com RBIN Task Flow
+- Melhores práticas de desenvolvimento
+
+Todas as regras são automaticamente ativas no Cursor. O IDE irá:
+- Seguir padrões de codificação de `.cursor/rules/`
+- Integrar com fluxos de trabalho do RBIN Task Flow
+- Seguir práticas de commit e git
+
+### Integração com Claude Code
+
+O Claude Code vem pré-configurado com:
+- Configurações personalizadas
+- Integração com RBIN Task Flow
+- Melhores práticas de desenvolvimento
+
+### Integração com Gemini
+
+O Gemini vem pré-configurado com:
+- Configurações personalizadas
+- Integração com RBIN Task Flow
+- Melhores práticas de desenvolvimento
+
+## O Que Está Configurado
+
+### Regras de Desenvolvimento
+
+Regras incluídas para:
+- Formatação de regras do Cursor
+- Processos de auto-melhoria
+- Padrões de comentários de código
+- Práticas de commit
+- Controle de comandos git
+- Gerenciamento de execução de tarefas
+
+### RBIN Task Flow
+
+Gerenciamento de tarefas simples e poderoso:
+- **Entrada de Texto Simples**: Escreva tarefas em `.task-flow/tasks.input.txt` usando formato simples
+- **Geração Alimentada por IA**: Transforma tarefas simples em subtarefas detalhadas e acionáveis
+- **Instruções Inteligentes**: Cada subtarefa inclui contexto, objetivos, etapas de implementação e validação
+- **Rastreamento Simples**: Gerenciamento de status baseado em JSON com comandos CLI fáceis
+- **Monitoramento de Progresso**: Feedback visual claro sobre a conclusão das tarefas
+
+## .gitignore Discreto
+
+O instalador adiciona estas entradas ao `.gitignore`:
+
+```gitignore
+.claude/
+.gemini/
+.cursor/
+.task-flow/
+CLAUDE.md
+GEMINI.md
+```
+
+**Por que discreto?**
+- Sem comentários explicando o que são
+- Sem menção a "IA", "Claude" ou "Anthropic"
+- Tudo relacionado ao RBIN Task Flow permanece local
+- Histórico git limpo sem arquivos de ferramentas de IA
+
+## Atualizando Projetos
+
+Para atualizar configurações em um projeto existente:
+
+```bash
+# Usando NPM (recomendado)
+cd /caminho/para/seu/projeto
+rbin-task-flow update
+
+# Ou usando método legacy
+~/.rbin-task-flow/install.sh
+# Digite o caminho do projeto
+```
+
+O instalador irá:
+- ✅ Copiar novas regras (sempre sobrescreve)
+- ✅ **Sobrescrever arquivos de configuração** (settings.json) com as versões mais recentes
+- ✅ Atualizar .gitignore se necessário
+- ✅ Atualizar scripts do Task Flow (sempre sobrescreve)
+- ✅ **Preservar seus dados**: `.internal/tasks.json` e `.internal/status.json` **NÃO são sobrescritos** (suas tarefas permanecem seguras)
+
+**Nota**: O instalador adiciona automaticamente `.task-flow/` ao `.gitignore`, mantendo seu progresso de tarefas privado e fora do controle de versão.
+
+## Estrutura do Projeto
+
+Este repositório contém:
+
+```
+rbin-task-flow/
+├── .cursor/
+│   ├── settings.json             # Configurações do modelo Cursor
+│   └── rules/                   # Todas as regras de desenvolvimento
+│
+├── .claude/
+│   └── settings.json             # Configurações do Claude Code
+│
+├── .gemini/
+│   └── settings.json             # Configurações do Gemini
+│
+├── .task-flow/
+│   ├── README.md                 # Referência rápida de comandos
+│   ├── tasks.input.txt           # Template de definições de tarefas
+│   ├── tasks.status.md           # ⚠️ Template de status de tarefas (NÃO EDITE manualmente)
+│   └── .internal/                # ⚠️ Arquivos internos do sistema (ignore - gerados automaticamente)
+│       ├── tasks.json            # Definições de tarefas (auto)
+│       └── status.json           # Rastreamento de status de tarefas (auto)
+│
+├── .gitignore                    # Template gitignore
+├── .model-versions.json          # Referência de versão do modelo (atualize quando novos modelos forem lançados)
+├── CLAUDE.md                     # Instruções principais do Claude
+├── GEMINI.md                     # Instruções principais do Gemini
+├── install.sh                    # Script de instalação
+└── README.md                     # Este arquivo
+```
+
+## Notas Importantes
+
+- ⚠️ Este é um **repositório template** - não use RBIN Task Flow aqui
+- ✅ Use RBIN Task Flow em **projetos que recebem** as configurações via instalação
+- 🔄 O instalador **sempre sobrescreve** configurações existentes
+- 🤫 As entradas do .gitignore são **discretas** (sem menções a IA)
+- 🎯 Funciona com **Claude Code CLI**, **API Gemini** ou **Cursor Pro**
+- 📦 O diretório Task Flow (`.task-flow/`) é **automaticamente gitignored**
+- 📝 Defina tarefas em `.task-flow/tasks.input.txt` usando formato simples: `- Descrição da tarefa`
+- 🚀 **Instalação Global NPM**: `npm install -g rbin-task-flow`, depois use `rbin-task-flow init` em qualquer projeto
+- 🔒 **Chaves de API podem ser necessárias** - depende do seu provedor de IA (Claude Code, API Gemini ou Cursor Pro)
+- 🔔 **Verificação de versão do modelo** - Use `rbin-task-flow version-check` para verificar versões mais recentes dos modelos (verificação rápida e local)
+
+## Atualizando Versões dos Modelos
+
+Quando novas versões de modelos forem lançadas, atualize `.model-versions.json` neste repositório:
+
+```json
+{
+  "claude": {
+    "current": "claude-sonnet-4-5-20250929",
+    "latest": "NOVA_VERSÃO_AQUI",
+    "checkUrl": "https://docs.anthropic.com/claude/docs/models-overview"
+  },
+  "cursor": {
+    "current": "claude-sonnet-4-5-20250929",
+    "latest": "NOVA_VERSÃO_AQUI",
+    "checkUrl": "https://docs.cursor.com/models"
+  },
+  "gemini": {
+    "current": "gemini-3-flash",
+    "latest": "NOVA_VERSÃO_AQUI",
+    "checkUrl": "https://ai.google.dev/models/gemini"
+  }
+}
+```
+
+O instalador verificará automaticamente versões mais recentes dos modelos e **perguntará individualmente** se você deseja atualizar cada um (Claude, Cursor, Gemini). Esta verificação é **rápida e local** - sem chamadas de API, sem solicitações de rede, apenas uma simples comparação de strings.
+
+**Atualizações Interativas:** Quando uma versão mais recente estiver disponível, o instalador irá:
+- Mostrar versões atuais e mais recentes
+- Perguntar: "Atualizar [Modelo] para a versão mais recente? [y/N]"
+- Atualizar apenas se você confirmar com `y`
+- Pular se você pressionar Enter ou digitar `n`
+
+**Importante:** As atualizações de versão do modelo funcionam de forma diferente:
+
+- **Ao instalar em um projeto de destino** (passando um caminho):
+  - O instalador **copia/substitui** arquivos do template do repositório para o projeto de destino
+  - **SEM prompts de atualização de modelo** - apenas copia o que está no template
+  - O projeto de destino recebe as versões atuais do template
+
+- **Ao executar o instalador no próprio repositório** (rbin-task-flow):
+  - Se novas versões de modelos forem detectadas, você pode escolher atualizá-las
+  - As atualizações são aplicadas **apenas aos arquivos do template do repositório**
+  - Após atualizar o template, execute o instalador nos projetos para aplicar as novas versões
+
+**Fluxo de Trabalho:**
+1. Execute o instalador em um projeto → copia arquivos do template atual para o projeto (sem prompts de atualização)
+2. Para atualizar o template do repositório → execute o instalador no próprio repositório, escolha atualizar
+3. Execute o instalador novamente nos projetos → copia arquivos do template atualizados para os projetos
+
+Você tem controle total - as atualizações de modelo acontecem apenas no template do repositório, não nos projetos de destino.
+
+## Contribuindo
+
+Contribuições são bem-vindas! Para adicionar novas regras ou melhorar templates:
+
+1. Faça um fork deste repositório
+2. Crie um branch de feature
+3. Adicione suas regras/templates seguindo os formatos existentes
+4. Teste em um projeto real
+5. Envie um Pull Request
+
+## Licença
+
+Licença MIT - Veja o arquivo LICENSE para detalhes
+
+## Suporte
+
+Para problemas ou perguntas:
+- Abra uma issue no GitHub
+- Verifique issues existentes para soluções
+- Consulte CHANGELOG.md para atualizações recentes
+
+---
+
+<a id="english"></a>
+# 🇬🇧 English
+
+## What Is This Project?
+
+RBIN Task Flow is an AI-powered task management system that automatically configures Claude Code, Gemini, and Cursor IDE in any project. You define tasks in plain text and the AI automatically generates detailed, actionable subtasks.
+
+**Key benefits:**
+- ✅ Global NPM installation - install once, use in any project
+- ✅ Zero configuration - ready to use immediately
+- ✅ Simple management - write tasks in text, AI does the rest
+- ✅ Multiple AI models - Claude, Gemini, and Cursor configured
 
 ## Installation
 
@@ -55,13 +424,75 @@ rbin-task-flow init
 
 **That's it!** RBIN Task Flow is now available globally on your system.
 
+## Commands
+
+### CLI Commands
+
+```bash
+rbin-task-flow init          # Initialize in current project
+rbin-task-flow update        # Update configurations
+rbin-task-flow version-check # Check for model updates
+rbin-task-flow info          # Show information
+```
+
+### AI Commands - Why Use Them?
+
+After initializing, use these commands in your AI (Cursor/Claude/Gemini) to automatically manage tasks:
+
+| Command | Why Use It | Key Feature |
+|---------|------------|-------------|
+| `task-flow: sync` | **Sync** tasks from text file with system | Keeps everything synchronized automatically - adds new, removes deleted, preserves your progress |
+| `task-flow: think` | **Discover** tasks you forgot | Analyzes code and suggests missing tasks (tests, refactoring, documentation) |
+| `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
+| `task-flow: run task X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
+| `task-flow: status` | **Visualize** progress quickly | See summary with completed tasks, in progress, and remaining subtasks |
+| `task-flow: review` | **Ensure** work quality | Verifies that tasks marked as "done" are actually completed |
+| `task-flow: refactor` | **Improve** code without breaking | Refactors code from current commit removing comments and improving quality |
+
+**Typical workflow:**
+
+```bash
+# 1. Install and initialize
+npm install -g rbin-task-flow
+cd my-project && rbin-task-flow init
+
+# 2. Edit tasks in plain text
+# Edit .task-flow/tasks.input.txt:
+# - Create authentication system
+# - Add tests
+
+# 3. Use AI commands:
+# "task-flow: sync" → Automatically generates detailed subtasks
+# "task-flow: run next 3" → AI works on next 3 subtasks
+# "task-flow: status" → View visual progress
+```
+
+## Overview
+
+A centralized repository of development configurations and rules that can be instantly installed in any project. Provides complete setup for Claude Code, Gemini, Cursor IDE, and RBIN Task Flow - a simple AI-powered task management system.
+
+### Key Features
+
+- **NPM Global Installation** - Install once, use everywhere with `npm install -g rbin-task-flow`
+- **Simple Task Management** - Define tasks in plain text, AI generates detailed subtasks
+- **Multiple AI Models** - Claude Code Sonnet and Gemini 3 Flash configured and ready to use
+- **Discrete .gitignore** - AI configs hidden with generic comments
+- **Zero Configuration** - Ready to use immediately
+- **RBIN Task Flow** - AI-powered task management with simple text interface
+
+## System Requirements
+
+- **Operating System:** macOS, Linux, or Windows (WSL)
+- **Tools:** Git, Bash, Node.js
+- **Required:** Claude Code CLI, Gemini API access, or Cursor IDE (with Pro subscription)
+
 ### Alternative: Legacy Installation (Without NPM)
 
 If you prefer the old method without npm:
 
 ```bash
 # 1. Clone this repository
-git clone https://github.com/rubensdeoliveira/rbin-task-flow.git ~/.rbin-task-flow
+git clone https://github.com/rbinoliveira/rbin-task-flow.git ~/.rbin-task-flow
 
 # 2. Install in your project
 ~/.rbin-task-flow/install.sh
@@ -109,60 +540,6 @@ No additional configuration required! Just make sure you have:
 
 **You're ready!**
 
-## Usage
-
-### RBIN Task Flow Commands
-
-After installing globally, you can use these commands:
-
-```bash
-# Initialize in current directory
-rbin-task-flow init
-
-# Update configurations
-rbin-task-flow update
-
-# Check for model version updates
-rbin-task-flow version-check
-
-# Show help information
-rbin-task-flow info
-```
-
-### AI Commands
-
-Once initialized in a project, use these AI commands:
-- `task-flow: sync` - Sincronização completa: adiciona novas, remove removidas, atualiza modificadas, preserva status
-- `task-flow: think` - Analisa código e sugere novas tasks
-- `task-flow: run next X` - Trabalha nas próximas X subtasks sequenciais
-- `task-flow: run task X` - Executa todas as subtasks pendentes da task X (só executa se tasks anteriores estiverem completas - permite trabalho paralelo)
-- `task-flow: status` - Mostra status atual das tasks
-- `task-flow: review` - Revisa tasks concluídas
-- `task-flow: refactor` - Refatora código do commit atual
-
-**Complete workflow:**
-
-```bash
-# 1. Install globally (one time)
-npm install -g rbin-task-flow
-
-# 2. Initialize in your project
-cd /path/to/my-project
-rbin-task-flow init
-
-# 3. Use AI commands:
-#    - Edit .task-flow/tasks.input.txt and use 'task-flow: sync' to generate
-#    - Use 'task-flow: run next X' to work on next X subtasks
-#    - Use 'task-flow: run task X' to work on all subtasks of task X
-#    - Use 'task-flow: status' to view progress
-```
-
-**Key features:**
-- ✅ **.task-flow/** directory is automatically **gitignored**
-- ✅ Your task progress stays **local and private**
-- ✅ Team members can use their own tasks without conflicts
-- ✅ AI generates detailed, actionable subtasks from simple descriptions
-
 ### Cursor Integration
 
 Cursor is pre-configured with:
@@ -376,6 +753,6 @@ For issues or questions:
 
 **Made with ❤️ for developers who love simple, AI-powered workflows**
 
-[⬆ Back to top](#rbin-task-flow)
+<a href="#português">🇧🇷 Português</a> | <a href="#english">🇬🇧 English</a> | <a href="#rbin-task-flow">⬆ Back to top</a>
 
 </div>

package/bin/cli.js

@@ -45,7 +45,7 @@ program
     console.log(chalk.cyan('╚════════════════════════════════════════════════════════════════╝') + '\n');
     console.log(chalk.blue('AI-powered task management for Claude, Cursor, and Gemini'));
     console.log(chalk.yellow('\nVersion:'), require('../package.json').version);
-    console.log(chalk.yellow('Repository:'), 'https://github.com/rubensdeoliveira/rbin-task-flow');
+    console.log(chalk.yellow('Repository:'), 'https://github.com/rbinoliveira/rbin-task-flow');
     console.log(chalk.yellow('\nCommands:'));
     console.log(chalk.cyan('  rbin-task-flow init') + '         - Initialize in current directory');
     console.log(chalk.cyan('  rbin-task-flow update') + '       - Update configurations');

package/lib/install.js

@@ -236,6 +236,9 @@ async function showModelVersions(targetPath) {
       if (settings.model) {
         console.log(chalk.blue('Claude:'), chalk.yellow(settings.model));
         hasModels = true;
+      } else {
+        console.log(chalk.blue('Claude:'), chalk.yellow('Default (recommended)'));
+        hasModels = true;
       }
     } catch (error) {
       // Ignorar erros de parsing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "AI-powered task management for Claude, Cursor, and Gemini",
   "main": "index.js",
   "bin": {
@@ -25,7 +25,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/rubensdeoliveira/rbin-task-flow.git"
+    "url": "https://github.com/rbinoliveira/rbin-task-flow.git"
   },
   "files": [
     "bin/",

package/.claude/settings.local.json

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