rbin-task-flow 1.1.2 → 1.3.0

package/.task-flow/README.md

@@ -1,66 +1,116 @@
-# RBIN Task Flow - Comandos Rápidos
-
-## 🚀 Comandos Rápidos
-
-| Comando | Descrição |
-|---------|-----------|
-| `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 (ex: `task-flow: run next 4`) |
-| `task-flow: run task X` | Executa todas as subtasks pendentes da task X (ex: `task-flow: run task 1`) |
-| `task-flow: status` | Mostra status atual das tasks |
-| `task-flow: review` | Revisa tasks marcadas como "done" |
-| `task-flow: refactor` | Refatora código do commit atual |
-
-**Veja detalhes completos abaixo ↓**
+# RBIN Task Flow - Quick Commands
+
+## 🚀 Quick Commands
+
+| Command | Description |
+|---------|-------------|
+| `task-flow: sync` | Complete synchronization: adds new, removes deleted, updates modified, preserves status |
+| `task-flow: think` | Analyzes code and suggests new tasks |
+| `task-flow: status` | Shows current task status |
+| `task-flow: run next X` | Works on next X subtasks (e.g., `task-flow: run next 4`) |
+| `task-flow: run X` | Executes all pending subtasks of task X (e.g., `task-flow: run 1`) |
+| `task-flow: run X,Y` | Executes multiple tasks (e.g., `task-flow: run 10,11`) |
+| `task-flow: run all` | Executes all tasks |
+| `task-flow: review X` | Reviews specific task(s) (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
+| `task-flow: refactor X` | Refactors specific task(s) (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
+| `task-flow: estimate X` | Estimates time for task X (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
+| `task-flow: report X` | Generates implementation report for task X (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
+
+**See complete details below ↓**
 
 ---
 
-## Comandos Detalhados
+## Detailed Commands
 
 ### `task-flow: sync`
-Sincronização completa entre `tasks.input.txt` e o sistema:
-- ✅ Adiciona novas tasks do `tasks.input.txt`
-- ✅ Remove tasks que foram removidas do `tasks.input.txt`
-- ✅ Atualiza tasks que foram modificadas no `tasks.input.txt`
-- ✅ Preserva o status (done/pending) das tasks existentes
-- ✅ Sincroniza status entre `status.json` e `tasks.status.md` (garante que estão sempre alinhados)
+Complete synchronization between `tasks.input.txt` and the system:
+- ✅ Adds new tasks from `tasks.input.txt`
+- ✅ Removes tasks that were deleted from `tasks.input.txt`
+- ✅ Updates tasks that were modified in `tasks.input.txt`
+- ✅ Preserves status (done/pending) of existing tasks
+- ✅ Synchronizes status between `status.json` and `tasks.status.md` (ensures they are always aligned)
 
 ### `task-flow: think`
-Analisa código e sugere novas tasks. Pergunta antes de adicionar ao `tasks.input.txt`.
+Analyzes code and suggests new tasks. Asks before adding to `tasks.input.txt`.
+
+### `task-flow: status`
+Shows current status of tasks and subtasks from the `tasks.status.md` file.
+
+---
+
+## Commands with Task ID
 
 ### `task-flow: run next X`
-Trabalha nas próximas X subtasks pendentes em ordem sequencial. Implementa e marca como "done".
+Works on next X pending subtasks in sequential order. Implements and marks as "done".
 
-**Exemplos:**
-- `task-flow: run next 4` → Próximas 4 subtasks
-- `task-flow: run next` → Próxima 1 subtask
+**Examples:**
+- `task-flow: run next 4` → Next 4 subtasks
+- `task-flow: run next` → Next 1 subtask
 
-### `task-flow: run task X`
-Executa todas as subtasks pendentes de uma task específica. Implementa e marca como "done".
+### `task-flow: run X` (simplified syntax)
+Executes all pending subtasks of a specific task. Implements and marks as "done".
 
-**⚠️ Verificação de Dependências:**
-- Só executa se todas as tasks anteriores (1, 2, ..., X-1) estiverem completamente concluídas
-- Permite trabalho paralelo por múltiplas IAs sem conflitos
-- Se houver tasks anteriores pendentes, avisa quais precisam ser concluídas primeiro
+**⚠️ Dependency Check:**
+- Only executes if all previous tasks (1, 2, ..., X-1) are completely finished
+- Allows parallel work by multiple AIs without conflicts
+- If there are pending previous tasks, warns which ones need to be completed first
 
-**Exemplos:**
-- `task-flow: run task 1` → Todas as subtasks pendentes da task 1 (sempre pode executar)
-- `task-flow: run task 3` → Só executa se tasks 1 e 2 estiverem completas
+**Examples:**
+- `task-flow: run 1` → All pending subtasks of task 1 (can always execute)
+- `task-flow: run 10,11` → All pending subtasks of tasks 10 and 11
+- `task-flow: run all` → All pending subtasks of all tasks
+- `task-flow: run 3` → Only executes if tasks 1 and 2 are complete
 
-### `task-flow: status`
-Mostra o status atual das tasks e subtasks do arquivo `tasks.status.md`.
+### `task-flow: review X`
+Reviews specific task(s) marked as "done" to verify they are actually completed.
+
+**Examples:**
+- `task-flow: review 1` → Reviews task 1
+- `task-flow: review 10,11` → Reviews tasks 10 and 11
+- `task-flow: review all` → Reviews all tasks
+
+### `task-flow: refactor X`
+Refactors code from specific task(s). Removes explanatory comments, improves code without changing functionality.
+
+**Examples:**
+- `task-flow: refactor 1` → Refactors task 1
+- `task-flow: refactor 10,11` → Refactors tasks 10 and 11
+- `task-flow: refactor all` → Refactors all tasks
+
+### `task-flow: estimate X` (simplified syntax)
+Estimates time required to complete task(s) based on the number of subtasks and developer experience level.
+
+**Output includes:**
+- Time estimates for Junior (0-2 years), Mid-level (3-5 years), and Senior (6+ years) developers
+- Estimates in hours and business days
+- Recommendation for management with buffer
+
+**Examples:**
+- `task-flow: estimate 1` → Shows time estimate for task 1
+- `task-flow: estimate 10,11` → Shows time estimates for tasks 10 and 11
+- `task-flow: estimate all` → Shows time estimates for all tasks
+
+### `task-flow: report X` (simplified syntax)
+Generates a detailed implementation report for completed task(s) in Markdown format.
+
+**Report includes:**
+- Task overview and completion status
+- List of completed subtasks
+- Files created and modified (detected from git history)
+- Code change summaries with analysis
+- Task creation and completion dates
 
-### `task-flow: review`
-Revisa tasks marcadas como "done" para verificar se estão realmente concluídas.
+**Report location:** `.task-flow/docs/task-X-implementation.md`
 
-### `task-flow: refactor`
-Refatora código do commit atual. Remove comentários explicativos, melhora código sem mudar funcionalidade.
+**Examples:**
+- `task-flow: report 1` → Generates report for task 1
+- `task-flow: report 10,11` → Generates reports for tasks 10 and 11
+- `task-flow: report all` → Generates reports for all tasks
 
 ---
 
-## Arquivos
+## Files
 
-- `.task-flow/tasks.input.txt` - Edite tasks aqui (formato: `- Task description`)
-- `.task-flow/tasks.status.md` - ⚠️ **NÃO EDITE** - Atualizado automaticamente pela IA
-- `.task-flow/.internal/` - ⚠️ **IGNORE** - Arquivos internos do sistema (não precisa ler nem editar)
+- `.task-flow/tasks.input.txt` - Edit tasks here (format: `- Task description`)
+- `.task-flow/tasks.status.md` - ⚠️ **DO NOT EDIT** - Automatically updated by AI
+- `.task-flow/.internal/` - ⚠️ **IGNORE** - Internal system files (no need to read or edit)

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

@@ -1,14 +1,14 @@
-# Screenshot de Exemplo
+# Example Screenshot
 
-Este é um arquivo placeholder. Substitua este arquivo por um screenshot real (PNG ou JPG).
+This is a placeholder file. Replace this file with a real screenshot (PNG or JPG).
 
-## Como adicionar screenshots:
+## How to add 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
+1. Add your image files (.png or .jpg) to this folder
+2. Use descriptive names in kebab-case
+3. RBIN Task Flow will automatically detect and reference the screenshots
 
-## Exemplos de nomes:
+## Example names:
 
 - `login_recover_signup.png`
 - `dashboard.png`
@@ -17,8 +17,7 @@ Este é um arquivo placeholder. Substitua este arquivo por um screenshot real (P
 - `prescriptions.png`
 - `medicine.png`
 
-## Referenciar em tasks:
-
-Para referenciar um screenshot específico em uma task, use:
-`task-flow-screen nome_do_arquivo.png`
+## Reference in tasks:
 
+To reference a specific screenshot in a task, use:
+`task-flow-screen filename.png`

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

@@ -9,10 +9,10 @@
 
 ## 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`
+- Add your screenshots to the `.task-flow/screens/` folder (PNG or JPG)
+- RBIN Task Flow automatically detects and references available screenshots when generating subtasks
+- To reference a specific screenshot in a task, use: `task-flow-screen filename.png`
+- Example: `- Create login screen task-flow-screen login.png`
 
 ## Tasks:
 

package/.task-flow/tasks.status.md

@@ -1,16 +1,16 @@
 # Task Status
 
-<!-- ⚠️ AVISO: Este arquivo é atualizado automaticamente pela IA. NÃO edite manualmente. -->
+<!-- ⚠️ WARNING: This file is automatically updated by AI. DO NOT edit manually. -->
 
-## 📊 Resumo
+## 📊 Summary
 
-- ✅ **Tasks Completas**: 0
-- ⏳ **Tasks em Andamento**: 0
-- 📝 **Subtasks Restantes**: 0
+- ✅ **Completed Tasks**: 0
+- ⏳ **Tasks in Progress**: 0
+- 📝 **Remaining Subtasks**: 0
 
 **Tasks:**
-- ⏳ Task 1: First task (0 subtasks restantes de 0)
-- ⏳ Task 2: Second task (0 subtasks restantes de 0)
+- ⏳ Task 1: First task (0 remaining subtasks out of 0)
+- ⏳ Task 2: Second task (0 remaining subtasks out of 0)
 
 ---
 

package/CLAUDE.md

@@ -16,12 +16,20 @@ This project uses RBIN Task Flow for task management:
 - **Task Definition**: Edit `.task-flow/tasks.input.txt` using simple format: `- Task description`
 - **AI Commands**: Use AI-powered commands for task management:
   - `task-flow: sync` - Synchronize tasks from tasks.input.txt
-  - `task-flow: run next X` - Work on next X subtasks
-  - `task-flow: run task X` - Execute all pending subtasks of task X
-  - `task-flow: status` - View current task status
-  - `task-flow: review` - Review completed tasks
   - `task-flow: think` - Analyze code and suggest new tasks
-  - `task-flow: refactor` - Refactor code from current commit
+  - `task-flow: status` - View current task status
+  - `task-flow: run next X` - Work on next X subtasks
+  - `task-flow: run X` - Execute all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` - Execute multiple tasks (comma-separated)
+  - `task-flow: run all` - Execute all tasks
+  - `task-flow: review X` - Review specific task(s) (comma-separated or "all")
+  - `task-flow: refactor X` - Refactor specific task(s) (comma-separated or "all")
+  - `task-flow: estimate X` - Estimate time for task X (simplified - no "task" needed)
+  - `task-flow: estimate X,Y` - Estimate multiple tasks (comma-separated)
+  - `task-flow: estimate all` - Estimate all tasks
+  - `task-flow: report X` - Generate implementation report for task X (simplified - no "task" needed)
+  - `task-flow: report X,Y` - Generate reports for multiple tasks (comma-separated)
+  - `task-flow: report all` - Generate reports for all tasks
 - **Files**:
   - `.task-flow/tasks.input.txt` - Define your tasks here
   - `.task-flow/tasks.status.md` - Auto-generated status (DO NOT EDIT manually)

package/GEMINI.md

@@ -16,12 +16,20 @@ This project uses RBIN Task Flow for task management:
 - **Task Definition**: Edit `.task-flow/tasks.input.txt` using simple format: `- Task description`
 - **AI Commands**: Use AI-powered commands for task management:
   - `task-flow: sync` - Synchronize tasks from tasks.input.txt
-  - `task-flow: run next X` - Work on next X subtasks
-  - `task-flow: run task X` - Execute all pending subtasks of task X
-  - `task-flow: status` - View current task status
-  - `task-flow: review` - Review completed tasks
   - `task-flow: think` - Analyze code and suggest new tasks
-  - `task-flow: refactor` - Refactor code from current commit
+  - `task-flow: status` - View current task status
+  - `task-flow: run next X` - Work on next X subtasks
+  - `task-flow: run X` - Execute all pending subtasks of task X (simplified - no "task" needed)
+  - `task-flow: run X,Y` - Execute multiple tasks (comma-separated)
+  - `task-flow: run all` - Execute all tasks
+  - `task-flow: review X` - Review specific task(s) (comma-separated or "all")
+  - `task-flow: refactor X` - Refactor specific task(s) (comma-separated or "all")
+  - `task-flow: estimate X` - Estimate time for task X (simplified - no "task" needed)
+  - `task-flow: estimate X,Y` - Estimate multiple tasks (comma-separated)
+  - `task-flow: estimate all` - Estimate all tasks
+  - `task-flow: report X` - Generate implementation report for task X (simplified - no "task" needed)
+  - `task-flow: report X,Y` - Generate reports for multiple tasks (comma-separated)
+  - `task-flow: report all` - Generate reports for all tasks
 - **Files**:
   - `.task-flow/tasks.input.txt` - Define your tasks here
   - `.task-flow/tasks.status.md` - Auto-generated status (DO NOT EDIT manually)

package/README.md

@@ -60,7 +60,7 @@ rbin-task-flow init
 # Edite .task-flow/tasks.input.txt e use:
 # - task-flow: sync
 # - task-flow: run next X
-# - task-flow: run task X
+# - task-flow: run X (ou task-flow: run X,Y ou task-flow: run all)
 ```
 
 **Pronto!** RBIN Task Flow agora está disponível globalmente no seu sistema.
@@ -74,6 +74,8 @@ 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
+rbin-task-flow estimate <ids> # Estima tempo (ex: "1" ou "1,2" ou "all")
+rbin-task-flow report <ids>  # Gera relatório (ex: "1" ou "1,2" ou "all")
 ```
 
 ### Comandos da IA - Por Que Usar?
@@ -84,11 +86,15 @@ Após inicializar, use estes comandos na IA (Cursor/Claude/Gemini) para gerencia
 |---------|--------------|-------------------|
 | `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 |
+| `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 X` | **Completa** uma tarefa inteira de uma vez | Executa todas as subtarefas de uma tarefa específica (permite trabalho paralelo) |
+| `task-flow: run X,Y` | **Completa** múltiplas tarefas | Executa tarefas separadas por vírgula (ex: `task-flow: run 10,11`) |
+| `task-flow: run all` | **Completa** todas as tarefas | Executa todas as tarefas pendentes |
+| `task-flow: review X` | **Garante** qualidade do trabalho | Verifica tarefas específicas (ex: `task-flow: review 1` ou `task-flow: review 10,11` ou `task-flow: review all`) |
+| `task-flow: refactor X` | **Melhora** código sem quebrar | Refatora tarefas específicas (ex: `task-flow: refactor 1` ou `task-flow: refactor 10,11` ou `task-flow: refactor all`) |
+| `task-flow: estimate X` | **Estima** tempo para gestão | Calcula estimativa de tempo (ex: `task-flow: estimate 1` ou `task-flow: estimate 10,11`) |
+| `task-flow: report X` | **Documenta** implementação | Gera relatório detalhado (ex: `task-flow: report 1` ou `task-flow: report 10,11`) |
 
 **Fluxo típico:**
 
@@ -419,7 +425,7 @@ rbin-task-flow init
 # Edit .task-flow/tasks.input.txt and use:
 # - task-flow: sync
 # - task-flow: run next X
-# - task-flow: run task X
+# - task-flow: run X (or task-flow: run X,Y or task-flow: run all)
 ```
 
 **That's it!** RBIN Task Flow is now available globally on your system.
@@ -433,6 +439,8 @@ 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
+rbin-task-flow estimate <ids> # Estimate time (e.g., "1" or "1,2" or "all")
+rbin-task-flow report <ids>   # Generate report (e.g., "1" or "1,2" or "all")
 ```
 
 ### AI Commands - Why Use Them?
@@ -443,11 +451,15 @@ After initializing, use these commands in your AI (Cursor/Claude/Gemini) to auto
 |---------|------------|-------------|
 | `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 |
+| `task-flow: run next X` | **Automate** work on next subtasks | AI works on next X subtasks sequentially, you just follow along |
+| `task-flow: run X` | **Complete** an entire task at once | Executes all subtasks of a specific task (allows parallel work) |
+| `task-flow: run X,Y` | **Complete** multiple tasks | Executes comma-separated tasks (e.g., `task-flow: run 10,11`) |
+| `task-flow: run all` | **Complete** all tasks | Executes all pending tasks |
+| `task-flow: review X` | **Ensure** work quality | Verifies specific tasks (e.g., `task-flow: review 1` or `task-flow: review 10,11` or `task-flow: review all`) |
+| `task-flow: refactor X` | **Improve** code without breaking | Refactors specific tasks (e.g., `task-flow: refactor 1` or `task-flow: refactor 10,11` or `task-flow: refactor all`) |
+| `task-flow: estimate X` | **Estimate** time for management | Calculates time estimate (e.g., `task-flow: estimate 1` or `task-flow: estimate 10,11`) |
+| `task-flow: report X` | **Document** implementation | Generates detailed report (e.g., `task-flow: report 1` or `task-flow: report 10,11`) |
 
 **Typical workflow:**
 

package/bin/cli.js

@@ -4,6 +4,8 @@ const { program } = require('commander');
 const path = require('path');
 const { installInProject } = require('../lib/install');
 const { checkVersionUpdates } = require('../lib/version');
+const { estimateTask } = require('../lib/estimate');
+const { generateReport } = require('../lib/report');
 const chalk = require('chalk');
 
 program
@@ -36,6 +38,26 @@ program
     await checkVersionUpdates();
   });
 
+program
+  .command('estimate')
+  .description('Estimate time for task(s) based on subtasks and experience level')
+  .argument('<taskIds>', 'Task ID(s) to estimate (comma-separated or "all")')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (taskIds, options) => {
+    const targetPath = options.path || process.cwd();
+    await estimateTask(taskIds, targetPath);
+  });
+
+program
+  .command('report')
+  .description('Generate implementation report for completed task(s)')
+  .argument('<taskIds>', 'Task ID(s) to generate report for (comma-separated or "all")')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (taskIds, options) => {
+    const targetPath = options.path || process.cwd();
+    await generateReport(taskIds, targetPath);
+  });
+
 program
   .command('info')
   .description('Show information about RBIN Task Flow')
@@ -50,6 +72,8 @@ program
     console.log(chalk.cyan('  rbin-task-flow init') + '         - Initialize in current directory');
     console.log(chalk.cyan('  rbin-task-flow update') + '       - Update configurations');
     console.log(chalk.cyan('  rbin-task-flow version-check') + ' - Check for model updates');
+    console.log(chalk.cyan('  rbin-task-flow estimate <ids>') + ' - Estimate time (e.g., "1" or "1,2" or "all")');
+    console.log(chalk.cyan('  rbin-task-flow report <ids>') + '  - Generate report (e.g., "1" or "1,2" or "all")');
     console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information\n');
   });
 

package/lib/estimate.js

@@ -0,0 +1,117 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { parseTaskIds } = require('./utils');
+
+async function estimateTask(taskIdsInput, targetPath = process.cwd()) {
+  const tasksPath = path.join(targetPath, '.task-flow/.internal/tasks.json');
+
+  if (!fs.existsSync(tasksPath)) {
+    console.log(chalk.red('❌ Tasks file not found. Run "task-flow: sync" first.'));
+    return;
+  }
+
+  try {
+    const tasksData = await fs.readJSON(tasksPath);
+    const taskIds = parseTaskIds(taskIdsInput, tasksData.tasks);
+    
+    if (taskIds.length === 0) {
+      console.log(chalk.red('❌ No valid task IDs provided.'));
+      return;
+    }
+
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (const taskId of taskIds) {
+      const task = tasksData.tasks.find(t => t.id === taskId);
+
+      if (!task) {
+        console.log(chalk.red(`❌ Task ${taskId} not found.`));
+        errorCount++;
+        continue;
+      }
+
+      const subtaskCount = task.subtasks ? task.subtasks.length : 0;
+
+      if (subtaskCount === 0) {
+        console.log(chalk.yellow(`⚠️  Task ${taskId} has no subtasks. Cannot estimate.`));
+        errorCount++;
+        continue;
+      }
+
+      const estimates = calculateEstimates(subtaskCount);
+
+      if (taskIds.length > 1) {
+        console.log('\n' + chalk.cyan('═'.repeat(70)));
+      } else {
+        console.log('\n' + chalk.cyan('═'.repeat(70)));
+      }
+      console.log(chalk.magenta('📊 Task Estimation Report'));
+      console.log(chalk.cyan('═'.repeat(70)) + '\n');
+
+      console.log(chalk.blue.bold('Task:'), chalk.yellow(`#${taskId} - ${task.title}\n`));
+      console.log(chalk.blue(`Complexity: ${chalk.yellow(subtaskCount)} subtasks\n`));
+
+      console.log(chalk.cyan('─'.repeat(70)));
+      console.log(chalk.magenta.bold('Time Estimates by Experience Level:\n'));
+
+      const juniorDays = Math.ceil(estimates.junior.upper / 8);
+      const midDays = Math.ceil(estimates.mid.upper / 8);
+      const seniorDays = Math.ceil(estimates.senior.upper / 8);
+
+      console.log(chalk.gray('👶 Junior Developer (0-2 years):'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.junior.lower}-${estimates.junior.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${juniorDays} business day(s)`));
+      console.log('');
+
+      console.log(chalk.gray('👨‍💼 Mid-level Developer (3-5 years):'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${midDays} business day(s)`));
+      console.log('');
+
+      console.log(chalk.gray('👴 Senior Developer (6+ years):'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.senior.lower}-${estimates.senior.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${seniorDays} business day(s)`));
+      console.log('');
+
+      console.log(chalk.cyan('─'.repeat(70)));
+      console.log(chalk.magenta.bold('Recommendation for Management:\n'));
+      console.log(chalk.white('   Recommended estimate:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`), chalk.gray('(mid-level baseline)'));
+      console.log(chalk.white('   Buffer recommended:'), chalk.yellow(`+20%`), chalk.gray('for unexpected issues'));
+      console.log(chalk.white('   Total estimate:'), chalk.yellow(`${Math.round(estimates.mid.upper * 1.2)} hours`), chalk.gray(`(~${Math.ceil(estimates.mid.upper * 1.2 / 8)} business days)`));
+      console.log('');
+
+      successCount++;
+    }
+
+    if (taskIds.length > 1) {
+      console.log(chalk.cyan(`\n📊 Estimated ${successCount} task(s), ${errorCount} error(s)`));
+    }
+
+  } catch (error) {
+    console.error(chalk.red('Error reading tasks:'), error.message);
+  }
+}
+
+function calculateEstimates(subtaskCount) {
+  const baseLower = subtaskCount * 2;
+  const baseUpper = subtaskCount * 3;
+
+  return {
+    junior: {
+      lower: Math.round(baseLower * 1.5),
+      upper: Math.round(baseUpper * 1.5)
+    },
+    mid: {
+      lower: baseLower,
+      upper: baseUpper
+    },
+    senior: {
+      lower: Math.round(baseLower * 0.7),
+      upper: Math.round(baseUpper * 0.7)
+    }
+  };
+}
+
+module.exports = { estimateTask };