rbin-task-flow 1.1.2 → 1.2.0

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 a task based on subtasks and experience level')
+  .argument('<taskId>', 'Task ID to estimate')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (taskId, options) => {
+    const targetPath = options.path || process.cwd();
+    await estimateTask(taskId, targetPath);
+  });
+
+program
+  .command('report')
+  .description('Generate implementation report for a completed task')
+  .argument('<taskId>', 'Task ID to generate report for')
+  .option('-p, --path <path>', 'Target directory (default: current directory)')
+  .action(async (taskId, options) => {
+    const targetPath = options.path || process.cwd();
+    await generateReport(taskId, 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 <id>') + ' - Estimate time for a task');
+    console.log(chalk.cyan('  rbin-task-flow report <id>') + '  - Generate implementation report');
     console.log(chalk.cyan('  rbin-task-flow info') + '         - Show this information\n');
   });
 

package/lib/estimate.js

@@ -0,0 +1,92 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+async function estimateTask(taskId, 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 task = tasksData.tasks.find(t => t.id === parseInt(taskId));
+
+    if (!task) {
+      console.log(chalk.red(`❌ Task ${taskId} not found.`));
+      return;
+    }
+
+    const subtaskCount = task.subtasks ? task.subtasks.length : 0;
+
+    if (subtaskCount === 0) {
+      console.log(chalk.yellow(`⚠️  Task ${taskId} has no subtasks. Cannot estimate.`));
+      return;
+    }
+
+    const estimates = calculateEstimates(subtaskCount);
+
+    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('');
+
+  } 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 };

package/lib/install.js

@@ -4,7 +4,6 @@ const chalk = require('chalk');
 const ora = require('ora');
 const { showHeader, showSuccess, showError, showWarning, showInfo, showNextSteps } = require('./utils');
 
-// Diretório onde o pacote npm está instalado globalmente
 const TEMPLATE_DIR = path.join(__dirname, '..');
 
 async function installInProject(targetPath, options = {}) {
@@ -23,13 +22,11 @@ async function installInProject(targetPath, options = {}) {
   const spinner = ora('Processing...').start();
 
   try {
-    // Verificar se diretório existe
     if (!fs.existsSync(targetPath)) {
       spinner.fail(chalk.red(`Directory not found: ${targetPath}`));
       process.exit(1);
     }
 
-    // Verificar permissões de escrita
     try {
       fs.accessSync(targetPath, fs.constants.W_OK);
     } catch (error) {
@@ -39,7 +36,6 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Creating directories...';
 
-    // Criar diretórios necessários
     const dirs = [
       '.cursor/rules',
       '.claude',
@@ -53,19 +49,16 @@ async function installInProject(targetPath, options = {}) {
 
     spinner.text = 'Copying configuration files...';
 
-    // Copiar arquivos de configuração
     await copyConfigs(targetPath);
 
     spinner.text = 'Updating .gitignore...';
 
-    // Atualizar .gitignore
     await updateGitignore(targetPath);
 
     spinner.succeed(chalk.green('Installation completed!'));
 
     console.log('');
 
-    // Mostrar versões configuradas
     await showModelVersions(targetPath);
 
     showNextSteps(targetPath);
@@ -78,7 +71,6 @@ async function installInProject(targetPath, options = {}) {
 }
 
 async function copyConfigs(targetPath) {
-  // Copiar regras do Cursor
   const cursorRulesPath = path.join(TEMPLATE_DIR, '.cursor/rules');
   if (fs.existsSync(cursorRulesPath)) {
     await fs.copy(
@@ -89,7 +81,6 @@ async function copyConfigs(targetPath) {
     showSuccess('Cursor rules');
   }
 
-  // Copiar settings do Cursor
   const cursorSettingsPath = path.join(TEMPLATE_DIR, '.cursor/settings.json');
   if (fs.existsSync(cursorSettingsPath)) {
     await fs.copy(
@@ -100,7 +91,6 @@ async function copyConfigs(targetPath) {
     showSuccess('Cursor settings');
   }
 
-  // Copiar settings do Claude
   const claudeSettingsPath = path.join(TEMPLATE_DIR, '.claude/settings.json');
   if (fs.existsSync(claudeSettingsPath)) {
     await fs.copy(
@@ -111,7 +101,6 @@ async function copyConfigs(targetPath) {
     showSuccess('Claude settings');
   }
 
-  // Copiar instruções do Claude
   const claudeInstructionsPath = path.join(TEMPLATE_DIR, 'CLAUDE.md');
   if (fs.existsSync(claudeInstructionsPath)) {
     await fs.copy(
@@ -122,7 +111,6 @@ async function copyConfigs(targetPath) {
     showSuccess('Claude instructions');
   }
 
-  // Copiar settings do Gemini
   const geminiSettingsPath = path.join(TEMPLATE_DIR, '.gemini/settings.json');
   if (fs.existsSync(geminiSettingsPath)) {
     await fs.copy(
@@ -133,7 +121,6 @@ async function copyConfigs(targetPath) {
     showSuccess('Gemini settings');
   }
 
-  // Copiar instruções do Gemini
   const geminiInstructionsPath = path.join(TEMPLATE_DIR, 'GEMINI.md');
   if (fs.existsSync(geminiInstructionsPath)) {
     await fs.copy(
@@ -144,7 +131,6 @@ async function copyConfigs(targetPath) {
     showSuccess('Gemini instructions');
   }
 
-  // Copiar Task Flow (preservando dados internos)
   await copyTaskFlow(targetPath);
 }
 
@@ -157,19 +143,20 @@ async function copyTaskFlow(targetPath) {
   showSuccess('Task Flow directory');
   showInfo('Note: .internal/tasks.json and .internal/status.json are NOT overwritten (your data is safe)');
 
-  // Criar pasta screens
   const screensDest = path.join(taskFlowDest, 'screens');
   await fs.ensureDir(screensDest);
   showSuccess('Screenshots directory (.task-flow/screens/)');
 
-  // Copiar arquivo de exemplo para screens se não existir
+  const docsDest = path.join(taskFlowDest, 'docs');
+  await fs.ensureDir(docsDest);
+  showSuccess('Documentation directory (.task-flow/docs/)');
+
   const exampleSrc = path.join(taskFlowSrc, 'screens/example.png.txt');
   const exampleDest = path.join(screensDest, 'example.png.txt');
   if (fs.existsSync(exampleSrc) && !fs.existsSync(exampleDest)) {
     await fs.copy(exampleSrc, exampleDest);
   }
 
-  // Copiar apenas templates, não sobrescrever dados do usuário
   const files = [
     { name: 'README.md', overwrite: true },
     { name: 'tasks.input.txt', overwrite: false },
@@ -181,27 +168,22 @@ async function copyTaskFlow(targetPath) {
     const dest = path.join(taskFlowDest, file.name);
 
     if (fs.existsSync(src)) {
-      // Sempre sobrescrever README, outros arquivos só se não existirem
       if (file.overwrite || !fs.existsSync(dest)) {
         await fs.copy(src, dest, { overwrite: file.overwrite });
       }
     }
   }
-
-  // Não copiar .internal - deixar que seja criado pela IA
 }
 
 async function updateGitignore(targetPath) {
   const gitignorePath = path.join(targetPath, '.gitignore');
 
-  // Criar se não existe
   if (!fs.existsSync(gitignorePath)) {
     await fs.writeFile(gitignorePath, '');
   }
 
   let content = await fs.readFile(gitignorePath, 'utf8');
 
-  // Entradas a adicionar
   const entries = [
     '.claude/',
     '.gemini/',
@@ -211,16 +193,13 @@ async function updateGitignore(targetPath) {
     'GEMINI.md'
   ];
 
-  // Remover entradas antigas (caso existam)
   for (const entry of entries) {
     const regex = new RegExp(`^${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'gm');
     content = content.replace(regex, '');
   }
 
-  // Remover linhas vazias consecutivas
   content = content.replace(/\n{3,}/g, '\n\n');
 
-  // Adicionar novas entradas
   if (!content.endsWith('\n')) {
     content += '\n';
   }
@@ -240,7 +219,6 @@ async function showModelVersions(targetPath) {
 
   let hasModels = false;
 
-  // Claude
   const claudeSettingsPath = path.join(targetPath, '.claude/settings.json');
   if (fs.existsSync(claudeSettingsPath)) {
     try {
@@ -253,11 +231,9 @@ async function showModelVersions(targetPath) {
         hasModels = true;
       }
     } catch (error) {
-      // Ignorar erros de parsing
     }
   }
 
-  // Cursor
   const cursorSettingsPath = path.join(targetPath, '.cursor/settings.json');
   if (fs.existsSync(cursorSettingsPath)) {
     try {
@@ -267,21 +243,24 @@ async function showModelVersions(targetPath) {
         hasModels = true;
       }
     } catch (error) {
-      // Ignorar erros de parsing
     }
   }
 
-  // Gemini
   const geminiSettingsPath = path.join(targetPath, '.gemini/settings.json');
   if (fs.existsSync(geminiSettingsPath)) {
     try {
       const settings = await fs.readJSON(geminiSettingsPath);
       if (settings.model) {
-        console.log(chalk.blue('Gemini:'), chalk.yellow(settings.model));
+        const modelName = typeof settings.model === 'string' 
+          ? settings.model 
+          : settings.model.name || 'Default (recommended)';
+        console.log(chalk.blue('Gemini:'), chalk.yellow(modelName));
+        hasModels = true;
+      } else {
+        console.log(chalk.blue('Gemini:'), chalk.yellow('Default (recommended)'));
         hasModels = true;
       }
     } catch (error) {
-      // Ignorar erros de parsing
     }
   }
 

package/lib/report.js

@@ -0,0 +1,278 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+
+async function generateReport(taskId, targetPath = process.cwd()) {
+  const tasksPath = path.join(targetPath, '.task-flow/.internal/tasks.json');
+  const statusPath = path.join(targetPath, '.task-flow/.internal/status.json');
+  const docsDir = path.join(targetPath, '.task-flow/docs');
+
+  if (!fs.existsSync(tasksPath)) {
+    console.log(chalk.red('❌ Tasks file not found. Run "task-flow: sync" first.'));
+    return;
+  }
+
+  if (!fs.existsSync(statusPath)) {
+    console.log(chalk.red('❌ Status file not found. Run "task-flow: sync" first.'));
+    return;
+  }
+
+  try {
+    const tasksData = await fs.readJSON(tasksPath);
+    const statusData = await fs.readJSON(statusPath);
+    
+    const task = tasksData.tasks.find(t => t.id === parseInt(taskId));
+
+    if (!task) {
+      console.log(chalk.red(`❌ Task ${taskId} not found.`));
+      return;
+    }
+
+    const taskStatus = statusData.tasks[taskId.toString()];
+    
+    if (!taskStatus) {
+      console.log(chalk.yellow(`⚠️  Task ${taskId} has no status information.`));
+    }
+
+    const isCompleted = taskStatus && taskStatus.status === 'done';
+    const allSubtasksDone = taskStatus && taskStatus.subtasks 
+      ? Object.values(taskStatus.subtasks).every(status => status === 'done')
+      : false;
+
+    if (!isCompleted && !allSubtasksDone) {
+      console.log(chalk.yellow(`⚠️  Task ${taskId} is not completed. Generating partial report...`));
+    }
+
+    await fs.ensureDir(docsDir);
+
+    const reportContent = await buildReport(task, taskStatus, targetPath);
+    const reportPath = path.join(docsDir, `task-${taskId}-implementation.md`);
+
+    await fs.writeFile(reportPath, reportContent, 'utf8');
+
+    console.log(chalk.green(`✅ Report generated: ${reportPath}`));
+
+  } catch (error) {
+    console.error(chalk.red('Error generating report:'), error.message);
+  }
+}
+
+async function buildReport(task, taskStatus, targetPath) {
+  const completionDate = new Date().toISOString().split('T')[0];
+  
+  let content = `# Task ${task.id}: ${task.title}\n\n`;
+  content += `**Status**: ${taskStatus?.status === 'done' ? '✅ Completed' : '⏳ In Progress'}\n`;
+  content += `**Report Date**: ${completionDate}\n\n`;
+  
+  content += `## Overview\n\n`;
+  content += `${task.description || task.originalRequest || 'No description available.'}\n\n`;
+
+  const completedSubtasks = task.subtasks?.filter(st => 
+    taskStatus?.subtasks?.[st.id.toString()] === 'done'
+  ) || [];
+
+  content += `## Implementation Summary\n\n`;
+  content += `This task was completed through ${completedSubtasks.length} of ${task.subtasks?.length || 0} subtasks. `;
+  content += `The implementation involved creating and modifying code files to achieve the task objectives.\n\n`;
+
+  const fileChanges = await getFileChanges(targetPath, task.id);
+  const changeSummaries = await analyzeFileChanges(targetPath, fileChanges);
+
+  if (fileChanges.created.length > 0 || fileChanges.modified.length > 0) {
+    content += `## Code Changes\n\n`;
+    
+    if (fileChanges.created.length > 0) {
+      content += `### New Files Created\n\n`;
+      fileChanges.created.forEach(file => {
+        const summary = changeSummaries[file];
+        content += `#### \`${file}\`\n\n`;
+        if (summary) {
+          content += `${summary}\n\n`;
+        } else {
+          content += `New file created as part of the implementation.\n\n`;
+        }
+      });
+    }
+    
+    if (fileChanges.modified.length > 0) {
+      content += `### Files Modified\n\n`;
+      fileChanges.modified.forEach(file => {
+        const summary = changeSummaries[file];
+        content += `#### \`${file}\`\n\n`;
+        if (summary) {
+          content += `${summary}\n\n`;
+        } else {
+          content += `File was modified to implement required functionality.\n\n`;
+        }
+      });
+    }
+  }
+
+  if (task.subtasks && completedSubtasks.length > 0) {
+    content += `## Completed Subtasks\n\n`;
+    
+    completedSubtasks.forEach(subtask => {
+      content += `### ✅ Subtask ${task.id}.${subtask.id}: ${subtask.title}\n\n`;
+      content += `${subtask.description || 'No description available.'}\n\n`;
+    });
+  }
+
+  if (fileChanges.created.length === 0 && fileChanges.modified.length === 0) {
+    content += `## Note\n\n`;
+    content += `_File changes could not be automatically detected from git history. `;
+    content += `This may indicate that changes haven't been committed yet, or the task was completed without git tracking._\n\n`;
+  }
+
+  if (task.createdAt) {
+    content += `---\n\n`;
+    content += `**Task Created**: ${new Date(task.createdAt).toLocaleDateString()}\n`;
+    if (taskStatus?.status === 'done') {
+      content += `**Task Completed**: ${completionDate}\n`;
+    }
+  }
+
+  return content;
+}
+
+async function getFileChanges(targetPath, taskId) {
+  const created = [];
+  const modified = [];
+
+  try {
+    const isGitRepo = fs.existsSync(path.join(targetPath, '.git'));
+    
+    if (!isGitRepo) {
+      return { created, modified };
+    }
+
+    const gitLog = execSync(
+      `git log --all --oneline --grep="task ${taskId}" --grep="Task ${taskId}" --grep="task-${taskId}" --grep="Task ${taskId}:" -i`,
+      { cwd: targetPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+    ).trim();
+
+    if (gitLog) {
+      const commits = gitLog.split('\n').map(line => line.split(' ')[0]);
+      
+      for (const commit of commits) {
+        try {
+          const diff = execSync(
+            `git diff-tree --no-commit-id --name-status -r ${commit}`,
+            { cwd: targetPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+          ).trim();
+
+          diff.split('\n').forEach(line => {
+            const match = line.match(/^([AMD])\s+(.+)$/);
+            if (match) {
+              const status = match[1];
+              const file = match[2];
+              
+              if (status === 'A') {
+                if (!created.includes(file)) created.push(file);
+              } else if (status === 'M' || status === 'D') {
+                if (!modified.includes(file) && !created.includes(file)) modified.push(file);
+              }
+            }
+          });
+        } catch (error) {
+        }
+      }
+    }
+  } catch (error) {
+  }
+
+  return { created, modified };
+}
+
+async function analyzeFileChanges(targetPath, fileChanges) {
+  const summaries = {};
+
+  for (const file of [...fileChanges.created, ...fileChanges.modified]) {
+    const filePath = path.join(targetPath, file);
+    
+    if (!fs.existsSync(filePath)) {
+      continue;
+    }
+
+    try {
+      const fileContent = await fs.readFile(filePath, 'utf8');
+      const fileExt = path.extname(file).toLowerCase();
+      
+      let summary = '';
+
+      if (fileChanges.created.includes(file)) {
+        summary = generateFileSummary(file, fileContent, fileExt, 'created');
+      } else {
+        summary = generateFileSummary(file, fileContent, fileExt, 'modified');
+      }
+
+      summaries[file] = summary;
+    } catch (error) {
+      summaries[file] = `File ${fileChanges.created.includes(file) ? 'created' : 'modified'} as part of the implementation.`;
+    }
+  }
+
+  return summaries;
+}
+
+function generateFileSummary(filePath, content, ext, type) {
+  const fileName = path.basename(filePath);
+  const lines = content.split('\n').length;
+  
+  let summary = '';
+  
+  if (type === 'created') {
+    summary = `This new file was created to implement part of the task. `;
+  } else {
+    summary = `This file was modified to implement required functionality. `;
+  }
+
+  summary += `The file contains approximately ${lines} lines of code. `;
+
+  if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx') {
+    const hasExports = /export\s+(default\s+)?(function|class|const|let|var|interface|type|enum)/.test(content);
+    const hasImports = /^import\s+/.test(content);
+    const hasComponents = /(function|const)\s+\w+\s*[=:]\s*(\(|function|React\.FC)/.test(content);
+    const functionCount = (content.match(/(?:function|const|let|var)\s+\w+\s*[=:]/g) || []).length;
+    const classCount = (content.match(/class\s+\w+/g) || []).length;
+    
+    if (hasComponents) {
+      summary += `It appears to be a React component or JavaScript module. `;
+    } else if (classCount > 0) {
+      summary += `It contains ${classCount} class${classCount > 1 ? 'es' : ''}. `;
+    } else if (functionCount > 0) {
+      summary += `It contains ${functionCount} function${functionCount > 1 ? 's' : ''} or method${functionCount > 1 ? 's' : ''}. `;
+    }
+    
+    if (hasExports) {
+      summary += `The file exports functionality for use in other parts of the application. `;
+    }
+    
+    if (hasImports) {
+      const importCount = (content.match(/^import\s+/gm) || []).length;
+      summary += `It imports ${importCount} dependenc${importCount > 1 ? 'ies' : 'y'} from other modules.`;
+    }
+  } else if (ext === '.css' || ext === '.scss' || ext === '.less') {
+    const ruleCount = (content.match(/[^{}]+{[^}]*}/g) || []).length;
+    summary += `It contains ${ruleCount} CSS rule${ruleCount !== 1 ? 's' : ''} for styling the user interface.`;
+  } else if (ext === '.json') {
+    summary += `It contains configuration or data in JSON format.`;
+  } else if (ext === '.md') {
+    summary += `It contains documentation or markdown content.`;
+  } else if (ext === '.test.ts' || ext === '.test.js' || ext === '.spec.ts' || ext === '.spec.js') {
+    const testCount = (content.match(/(?:it|test|describe|test\(|it\(|describe\()/g) || []).length;
+    summary += `It contains ${testCount} test case${testCount !== 1 ? 's' : ''} for verifying the implementation.`;
+  } else if (ext === '.html') {
+    summary += `It contains HTML markup for the user interface.`;
+  } else if (ext === '.py') {
+    const functionCount = (content.match(/def\s+\w+/g) || []).length;
+    const classCount = (content.match(/class\s+\w+/g) || []).length;
+    summary += `It contains ${functionCount} function${functionCount !== 1 ? 's' : ''} and ${classCount} class${classCount !== 1 ? 'es' : ''}.`;
+  } else {
+    summary += `It is a ${ext.substring(1).toUpperCase()} file.`;
+  }
+
+  return summary;
+}
+
+module.exports = { generateReport };

package/lib/version.js

@@ -35,17 +35,14 @@ async function checkVersionUpdates() {
 
     const rl = createInterface();
 
-    // Check Claude
     if (versions.claude) {
       await checkModelVersion('Claude', versions.claude, '.claude/settings.json', rl);
     }
 
-    // Check Cursor
     if (versions.cursor) {
       await checkModelVersion('Cursor', versions.cursor, '.cursor/settings.json', rl);
     }
 
-    // Check Gemini
     if (versions.gemini) {
       await checkModelVersion('Gemini', versions.gemini, '.gemini/settings.json', rl);
     }
@@ -69,7 +66,9 @@ async function checkModelVersion(modelName, versionInfo, settingsPath, rl) {
 
   try {
     const settings = await fs.readJSON(fullSettingsPath);
-    const currentVersion = settings.model;
+    const currentVersion = typeof settings.model === 'string' 
+      ? settings.model 
+      : settings.model?.name;
 
     if (!currentVersion) {
       console.log(chalk.gray(`${modelName}: No model configured`));
@@ -95,7 +94,11 @@ async function checkModelVersion(modelName, versionInfo, settingsPath, rl) {
       );
 
       if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-        settings.model = versionInfo.latest;
+        if (typeof settings.model === 'object' && settings.model !== null) {
+          settings.model.name = versionInfo.latest;
+        } else {
+          settings.model = versionInfo.latest;
+        }
         await fs.writeJSON(fullSettingsPath, settings, { spaces: 2 });
         console.log(chalk.green(`  ✅ ${modelName} updated to ${versionInfo.latest}`));
         console.log(chalk.cyan('     (Repository template updated - run init/update on projects to apply)'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "AI-powered task management for Claude, Cursor, and Gemini",
   "main": "index.js",
   "bin": {