rbin-task-flow 1.0.0

package/lib/install.js

@@ -0,0 +1,280 @@
+const fs = require('fs-extra');
+const path = require('path');
+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 = {}) {
+  const isUpdate = options.update || false;
+
+  showHeader();
+
+  if (isUpdate) {
+    console.log(chalk.blue('🔄 Updating RBIN Task Flow...'));
+  } else {
+    console.log(chalk.blue('🚀 Installing RBIN Task Flow...'));
+  }
+
+  console.log(chalk.blue('📁 Target:'), targetPath, '\n');
+
+  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) {
+      spinner.fail(chalk.red('No write permission in target directory'));
+      process.exit(1);
+    }
+
+    spinner.text = 'Creating directories...';
+
+    // Criar diretórios necessários
+    const dirs = [
+      '.cursor/rules',
+      '.claude',
+      '.gemini',
+      '.task-flow'
+    ];
+
+    for (const dir of dirs) {
+      await fs.ensureDir(path.join(targetPath, dir));
+    }
+
+    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);
+
+  } catch (error) {
+    spinner.fail(chalk.red('Installation failed'));
+    console.error(chalk.red('\nError:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function copyConfigs(targetPath) {
+  // Copiar regras do Cursor
+  const cursorRulesPath = path.join(TEMPLATE_DIR, '.cursor/rules');
+  if (fs.existsSync(cursorRulesPath)) {
+    await fs.copy(
+      cursorRulesPath,
+      path.join(targetPath, '.cursor/rules'),
+      { overwrite: true }
+    );
+    showSuccess('Cursor rules');
+  }
+
+  // Copiar settings do Cursor
+  const cursorSettingsPath = path.join(TEMPLATE_DIR, '.cursor/settings.json');
+  if (fs.existsSync(cursorSettingsPath)) {
+    await fs.copy(
+      cursorSettingsPath,
+      path.join(targetPath, '.cursor/settings.json'),
+      { overwrite: true }
+    );
+    showSuccess('Cursor settings');
+  }
+
+  // Copiar settings do Claude
+  const claudeSettingsPath = path.join(TEMPLATE_DIR, '.claude/settings.json');
+  if (fs.existsSync(claudeSettingsPath)) {
+    await fs.copy(
+      claudeSettingsPath,
+      path.join(targetPath, '.claude/settings.json'),
+      { overwrite: true }
+    );
+    showSuccess('Claude settings');
+  }
+
+  // Copiar instruções do Claude
+  const claudeInstructionsPath = path.join(TEMPLATE_DIR, 'CLAUDE.md');
+  if (fs.existsSync(claudeInstructionsPath)) {
+    await fs.copy(
+      claudeInstructionsPath,
+      path.join(targetPath, 'CLAUDE.md'),
+      { overwrite: true }
+    );
+    showSuccess('Claude instructions');
+  }
+
+  // Copiar settings do Gemini
+  const geminiSettingsPath = path.join(TEMPLATE_DIR, '.gemini/settings.json');
+  if (fs.existsSync(geminiSettingsPath)) {
+    await fs.copy(
+      geminiSettingsPath,
+      path.join(targetPath, '.gemini/settings.json'),
+      { overwrite: true }
+    );
+    showSuccess('Gemini settings');
+  }
+
+  // Copiar instruções do Gemini
+  const geminiInstructionsPath = path.join(TEMPLATE_DIR, 'GEMINI.md');
+  if (fs.existsSync(geminiInstructionsPath)) {
+    await fs.copy(
+      geminiInstructionsPath,
+      path.join(targetPath, 'GEMINI.md'),
+      { overwrite: true }
+    );
+    showSuccess('Gemini instructions');
+  }
+
+  // Copiar Task Flow (preservando dados internos)
+  await copyTaskFlow(targetPath);
+}
+
+async function copyTaskFlow(targetPath) {
+  const taskFlowSrc = path.join(TEMPLATE_DIR, '.task-flow');
+  const taskFlowDest = path.join(targetPath, '.task-flow');
+
+  await fs.ensureDir(taskFlowDest);
+
+  showSuccess('Task Flow directory');
+  showInfo('Note: .internal/tasks.json and .internal/status.json are NOT overwritten (your data is safe)');
+
+  // Copiar apenas templates, não sobrescrever dados do usuário
+  const files = [
+    { name: 'README.md', overwrite: true },
+    { name: 'tasks.input.txt', overwrite: false },
+    { name: 'tasks.status.md', overwrite: false }
+  ];
+
+  for (const file of files) {
+    const src = path.join(taskFlowSrc, file.name);
+    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/',
+    '.cursor/',
+    '.task-flow/',
+    'CLAUDE.md',
+    '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';
+  }
+
+  content += '\n' + entries.join('\n') + '\n';
+
+  await fs.writeFile(gitignorePath, content);
+
+  showSuccess('.gitignore updated');
+}
+
+async function showModelVersions(targetPath) {
+  console.log(chalk.cyan('═'.repeat(60)));
+  console.log(chalk.magenta('📋 Model Versions Configured:'));
+  console.log(chalk.cyan('═'.repeat(60)));
+  console.log('');
+
+  let hasModels = false;
+
+  // Claude
+  const claudeSettingsPath = path.join(targetPath, '.claude/settings.json');
+  if (fs.existsSync(claudeSettingsPath)) {
+    try {
+      const settings = await fs.readJSON(claudeSettingsPath);
+      if (settings.model) {
+        console.log(chalk.blue('Claude:'), chalk.yellow(settings.model));
+        hasModels = true;
+      }
+    } catch (error) {
+      // Ignorar erros de parsing
+    }
+  }
+
+  // Cursor
+  const cursorSettingsPath = path.join(targetPath, '.cursor/settings.json');
+  if (fs.existsSync(cursorSettingsPath)) {
+    try {
+      const settings = await fs.readJSON(cursorSettingsPath);
+      if (settings.model) {
+        console.log(chalk.blue('Cursor:'), chalk.yellow(settings.model));
+        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));
+        hasModels = true;
+      }
+    } catch (error) {
+      // Ignorar erros de parsing
+    }
+  }
+
+  if (!hasModels) {
+    console.log(chalk.yellow('No model versions configured yet'));
+  }
+
+  console.log('');
+}
+
+module.exports = { installInProject };

package/lib/utils.js

@@ -0,0 +1,45 @@
+const chalk = require('chalk');
+
+function showHeader() {
+  console.clear();
+  console.log(chalk.cyan('╔════════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║') + '        ' + chalk.magenta('✨ RBIN Task Flow - Installation ✨') + '          ' + chalk.cyan('║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════════════════════╝') + '\n');
+}
+
+function showSuccess(message) {
+  console.log(chalk.green('✅ ' + message));
+}
+
+function showError(message) {
+  console.log(chalk.red('❌ ' + message));
+}
+
+function showWarning(message) {
+  console.log(chalk.yellow('⚠️  ' + message));
+}
+
+function showInfo(message) {
+  console.log(chalk.blue('ℹ️  ' + message));
+}
+
+function showNextSteps(targetPath) {
+  console.log('\n' + chalk.cyan('═'.repeat(60)));
+  console.log(chalk.magenta.bold('  Next Steps:'));
+  console.log(chalk.cyan('═'.repeat(60)));
+  console.log(chalk.blue('  1.'), 'Edit', chalk.yellow('.task-flow/tasks.input.txt'));
+  console.log(chalk.blue('  2.'), 'Use AI command:', chalk.cyan('task-flow: sync'));
+  console.log(chalk.blue('  3.'), 'Work on tasks:', chalk.cyan('task-flow: run next X'));
+  console.log(chalk.blue('  4.'), 'Check status:', chalk.cyan('task-flow: status'));
+  console.log(chalk.cyan('═'.repeat(60)));
+  console.log(chalk.blue('\n  See'), chalk.yellow('.task-flow/README.md'), chalk.blue('for all available commands\n'));
+}
+
+module.exports = {
+  showHeader,
+  showSuccess,
+  showError,
+  showWarning,
+  showInfo,
+  showNextSteps
+};

package/lib/version.js

@@ -0,0 +1,114 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const readline = require('readline');
+
+const TEMPLATE_DIR = path.join(__dirname, '..');
+
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+function question(rl, query) {
+  return new Promise((resolve) => {
+    rl.question(query, resolve);
+  });
+}
+
+async function checkVersionUpdates() {
+  const versionsFilePath = path.join(TEMPLATE_DIR, '.model-versions.json');
+
+  if (!fs.existsSync(versionsFilePath)) {
+    console.log(chalk.yellow('⚠️  No version file found'));
+    return;
+  }
+
+  try {
+    const versions = await fs.readJSON(versionsFilePath);
+
+    console.log('\n' + chalk.cyan('╔════════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan('║') + '        ' + chalk.magenta('📋 Model Version Check') + '                           ' + chalk.cyan('║'));
+    console.log(chalk.cyan('╚════════════════════════════════════════════════════════════════╝') + '\n');
+
+    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);
+    }
+
+    rl.close();
+
+    console.log(chalk.green('\n✅ Version check completed!\n'));
+
+  } catch (error) {
+    console.error(chalk.red('Error reading version file:'), error.message);
+  }
+}
+
+async function checkModelVersion(modelName, versionInfo, settingsPath, rl) {
+  const fullSettingsPath = path.join(TEMPLATE_DIR, settingsPath);
+
+  if (!fs.existsSync(fullSettingsPath)) {
+    console.log(chalk.gray(`${modelName}: Settings file not found`));
+    return;
+  }
+
+  try {
+    const settings = await fs.readJSON(fullSettingsPath);
+    const currentVersion = settings.model;
+
+    if (!currentVersion) {
+      console.log(chalk.gray(`${modelName}: No model configured`));
+      return;
+    }
+
+    console.log('');
+    console.log(chalk.blue('━'.repeat(60)));
+    console.log(chalk.blue.bold(`${modelName}:`));
+    console.log(chalk.cyan('  Current:'), chalk.yellow(currentVersion));
+    console.log(chalk.cyan('  Latest:'), chalk.yellow(versionInfo.latest));
+
+    if (versionInfo.checkUrl) {
+      console.log(chalk.cyan('  Info:'), chalk.gray(versionInfo.checkUrl));
+    }
+
+    if (currentVersion !== versionInfo.latest) {
+      console.log(chalk.yellow('\n  ⚠️  New version available!'));
+
+      const answer = await question(
+        rl,
+        chalk.blue(`  Update ${modelName} to ${versionInfo.latest}? [y/N]: `)
+      );
+
+      if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+        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)'));
+      } else {
+        console.log(chalk.cyan('     Skipped update'));
+      }
+    } else {
+      console.log(chalk.green('  ✅ Up to date'));
+    }
+
+  } catch (error) {
+    console.log(chalk.red(`${modelName}: Error reading settings -`), error.message);
+  }
+}
+
+module.exports = { checkVersionUpdates };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "rbin-task-flow",
+  "version": "1.0.0",
+  "description": "AI-powered task management for Claude, Cursor, and Gemini",
+  "main": "index.js",
+  "bin": {
+    "rbin-task-flow": "./bin/cli.js",
+    "task-flow": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"No tests yet\"",
+    "prepublishOnly": "chmod +x bin/cli.js"
+  },
+  "keywords": [
+    "task-flow",
+    "ai",
+    "claude",
+    "cursor",
+    "gemini",
+    "cli",
+    "task-management",
+    "ai-powered"
+  ],
+  "author": "Rubens de Oliveira",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rubensdeoliveira/rbin-task-flow.git"
+  },
+  "files": [
+    "bin/",
+    ".cursor/",
+    ".claude/",
+    ".gemini/",
+    ".task-flow/",
+    ".model-versions.json",
+    "CLAUDE.md",
+    "GEMINI.md",
+    "lib/"
+  ],
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "fs-extra": "^11.0.0",
+    "ora": "^5.4.1"
+  }
+}