sincron-auto 1.0.0

package/bin/install.js

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasUninstall = args.includes('--uninstall') || args.includes('-u');
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    const value = configDirArg.split('=')[1];
+    if (!value) {
+      console.error(`  ${yellow}--config-dir requires a non-empty path${reset}`);
+      process.exit(1);
+    }
+    return value;
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+
+const banner = `
+${cyan} ███████╗ ██╗ ███╗   ██╗  ██████╗ ██████╗   ██████╗  ███╗   ██╗
+ ██╔════╝ ██║ ████╗  ██║ ██╔════╝ ██╔══██╗ ██╔═══██╗ ████╗  ██║
+ ███████╗ ██║ ██╔██╗ ██║ ██║      ██████╔╝ ██║   ██║ ██╔██╗ ██║
+ ╚════██║ ██║ ██║╚██╗██║ ██║      ██╔══██╗ ██║   ██║ ██║╚██╗██║
+ ███████║ ██║ ██║ ╚████║ ╚██████╗ ██║  ██║ ╚██████╔╝ ██║ ╚████║
+ ╚══════╝ ╚═╝ ╚═╝  ╚═══╝  ╚═════╝ ╚═╝  ╚═╝  ╚═════╝  ╚═╝  ╚═══╝${reset}
+
+  ${green}Sincron-Auto${reset} ${dim}v${pkg.version}${reset}
+  Plugin de automação multi-agente para Claude Code.
+  Do planejamento à execução, com inteligência distribuída.
+`;
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Uso:${reset} npx sincron-auto [opções]
+
+  ${yellow}Opções:${reset}
+    ${cyan}-g, --global${reset}              Instalar globalmente (~/.claude)
+    ${cyan}-l, --local${reset}               Instalar localmente (./.claude)
+    ${cyan}-u, --uninstall${reset}           Desinstalar Sincron-Auto
+    ${cyan}-c, --config-dir <path>${reset}   Especificar diretório de config
+    ${cyan}-h, --help${reset}                Mostrar esta ajuda
+
+  ${yellow}Exemplos:${reset}
+    ${dim}# Instalação interativa${reset}
+    npx sincron-auto
+
+    ${dim}# Instalar globalmente${reset}
+    npx sincron-auto --global
+
+    ${dim}# Instalar apenas no projeto atual${reset}
+    npx sincron-auto --local
+
+    ${dim}# Desinstalar globalmente${reset}
+    npx sincron-auto --global --uninstall
+
+  ${yellow}Comandos disponíveis após instalação:${reset}
+    ${cyan}/sincron-auto${reset}  - Iniciar workflow de automação multi-agente
+`);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Get the global config directory for Claude Code
+ */
+function getGlobalDir(explicitDir = null) {
+  if (explicitDir) {
+    return expandTilde(explicitDir);
+  }
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    return expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  }
+  return path.join(os.homedir(), '.claude');
+}
+
+/**
+ * Read and parse settings.json
+ */
+function readSettings(settingsPath) {
+  if (fs.existsSync(settingsPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Write settings.json with proper formatting
+ */
+function writeSettings(settingsPath, settings) {
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+/**
+ * Recursively copy directory, replacing paths in .md files
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true });
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix);
+    } else if (entry.name.endsWith('.md')) {
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      fs.writeFileSync(destPath, content);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Verify a directory exists and contains files
+ */
+function verifyInstalled(dirPath, description) {
+  if (!fs.existsSync(dirPath)) {
+    console.error(`  ${yellow}✗${reset} Falha ao instalar ${description}: diretório não criado`);
+    return false;
+  }
+  try {
+    const entries = fs.readdirSync(dirPath);
+    if (entries.length === 0) {
+      console.error(`  ${yellow}✗${reset} Falha ao instalar ${description}: diretório vazio`);
+      return false;
+    }
+  } catch (e) {
+    console.error(`  ${yellow}✗${reset} Falha ao instalar ${description}: ${e.message}`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Uninstall Sincron-Auto from the specified directory
+ */
+function uninstall(isGlobal) {
+  const targetDir = isGlobal
+    ? getGlobalDir(explicitConfigDir)
+    : path.join(process.cwd(), '.claude');
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  console.log(`  Desinstalando Sincron-Auto de ${cyan}${locationLabel}${reset}\n`);
+
+  if (!fs.existsSync(targetDir)) {
+    console.log(`  ${yellow}⚠${reset} Diretório não existe: ${locationLabel}`);
+    console.log(`  Nada para desinstalar.\n`);
+    return;
+  }
+
+  let removedCount = 0;
+
+  // 1. Remove sincron-auto command
+  const commandsDir = path.join(targetDir, 'commands');
+  if (fs.existsSync(commandsDir)) {
+    const cmdPath = path.join(commandsDir, 'sincron-auto.md');
+    if (fs.existsSync(cmdPath)) {
+      fs.unlinkSync(cmdPath);
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removido comando sincron-auto`);
+    }
+  }
+
+  // 2. Remove sincron-auto agents
+  const agentsDir = path.join(targetDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    const agentsToRemove = ['orquestrador.md', 'avaliador.md', 'construtor.md', 'estrutura.md', 'gestor-projeto.md'];
+    let agentCount = 0;
+    for (const agent of agentsToRemove) {
+      const agentPath = path.join(agentsDir, agent);
+      if (fs.existsSync(agentPath)) {
+        fs.unlinkSync(agentPath);
+        agentCount++;
+      }
+    }
+    if (agentCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removidos ${agentCount} agentes`);
+    }
+  }
+
+  // 3. Remove sincron-auto skills
+  const skillsDir = path.join(targetDir, 'skills');
+  if (fs.existsSync(skillsDir)) {
+    const skillsToRemove = ['autorizacao', 'avaliacao', 'gerenciar', 'instalar-mcp', 'projetar', 'relatorio-final'];
+    let skillCount = 0;
+    for (const skill of skillsToRemove) {
+      const skillPath = path.join(skillsDir, skill);
+      if (fs.existsSync(skillPath)) {
+        fs.rmSync(skillPath, { recursive: true });
+        skillCount++;
+      }
+    }
+    if (skillCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removidas ${skillCount} skills`);
+    }
+  }
+
+  // 4. Remove sincron-auto templates/docs
+  const sincronAutoDir = path.join(targetDir, 'sincron-auto');
+  if (fs.existsSync(sincronAutoDir)) {
+    fs.rmSync(sincronAutoDir, { recursive: true });
+    removedCount++;
+    console.log(`  ${green}✓${reset} Removido sincron-auto/`);
+  }
+
+  if (removedCount === 0) {
+    console.log(`  ${yellow}⚠${reset} Nenhum arquivo do Sincron-Auto encontrado.`);
+  }
+
+  console.log(`
+  ${green}Pronto!${reset} Sincron-Auto foi desinstalado.
+  Seus outros arquivos e configurações foram preservados.
+`);
+}
+
+/**
+ * Install Sincron-Auto to the specified directory
+ */
+function install(isGlobal) {
+  const src = path.join(__dirname, '..');
+  const targetDir = isGlobal
+    ? getGlobalDir(explicitConfigDir)
+    : path.join(process.cwd(), '.claude');
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  const pathPrefix = isGlobal
+    ? `${targetDir}/`
+    : './.claude/';
+
+  console.log(`  Instalando em ${cyan}${locationLabel}${reset}\n`);
+
+  const failures = [];
+
+  // 1. Create directories
+  fs.mkdirSync(path.join(targetDir, 'commands'), { recursive: true });
+  fs.mkdirSync(path.join(targetDir, 'agents'), { recursive: true });
+  fs.mkdirSync(path.join(targetDir, 'skills'), { recursive: true });
+
+  // 2. Copy command
+  const commandsSrc = path.join(src, 'commands');
+  if (fs.existsSync(commandsSrc)) {
+    const commandFiles = fs.readdirSync(commandsSrc).filter(f => f.endsWith('.md'));
+    for (const file of commandFiles) {
+      let content = fs.readFileSync(path.join(commandsSrc, file), 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      fs.writeFileSync(path.join(targetDir, 'commands', file), content);
+    }
+    console.log(`  ${green}✓${reset} Instalado ${commandFiles.length} comando(s)`);
+  } else {
+    failures.push('commands');
+  }
+
+  // 3. Copy agents
+  const agentsSrc = path.join(src, 'agents');
+  if (fs.existsSync(agentsSrc)) {
+    const agentFiles = fs.readdirSync(agentsSrc).filter(f => f.endsWith('.md'));
+    for (const file of agentFiles) {
+      let content = fs.readFileSync(path.join(agentsSrc, file), 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      fs.writeFileSync(path.join(targetDir, 'agents', file), content);
+    }
+    console.log(`  ${green}✓${reset} Instalados ${agentFiles.length} agentes`);
+  } else {
+    failures.push('agents');
+  }
+
+  // 4. Copy skills
+  const skillsSrc = path.join(src, 'skills');
+  if (fs.existsSync(skillsSrc)) {
+    const skillDirs = fs.readdirSync(skillsSrc, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const dir of skillDirs) {
+      const srcSkillDir = path.join(skillsSrc, dir.name);
+      const destSkillDir = path.join(targetDir, 'skills', dir.name);
+      copyWithPathReplacement(srcSkillDir, destSkillDir, pathPrefix);
+    }
+    console.log(`  ${green}✓${reset} Instaladas ${skillDirs.length} skills`);
+  } else {
+    failures.push('skills');
+  }
+
+  // 5. Copy templates to sincron-auto directory
+  const templatesSrc = path.join(src, 'templates');
+  const templatesDest = path.join(targetDir, 'sincron-auto', 'templates');
+  if (fs.existsSync(templatesSrc)) {
+    copyWithPathReplacement(templatesSrc, templatesDest, pathPrefix);
+    if (verifyInstalled(templatesDest, 'templates')) {
+      console.log(`  ${green}✓${reset} Instalados templates`);
+    } else {
+      failures.push('templates');
+    }
+  }
+
+  // 6. Copy docs
+  const docsSrc = path.join(src, 'docs');
+  const docsDest = path.join(targetDir, 'sincron-auto', 'docs');
+  if (fs.existsSync(docsSrc)) {
+    copyWithPathReplacement(docsSrc, docsDest, pathPrefix);
+    if (verifyInstalled(docsDest, 'docs')) {
+      console.log(`  ${green}✓${reset} Instalada documentação`);
+    } else {
+      failures.push('docs');
+    }
+  }
+
+  // 7. Write VERSION file
+  const versionDest = path.join(targetDir, 'sincron-auto', 'VERSION');
+  fs.mkdirSync(path.dirname(versionDest), { recursive: true });
+  fs.writeFileSync(versionDest, pkg.version);
+  console.log(`  ${green}✓${reset} Escrito VERSION (${pkg.version})`);
+
+  if (failures.length > 0) {
+    console.error(`\n  ${yellow}Instalação incompleta!${reset} Falhou: ${failures.join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`
+  ${green}Pronto!${reset} Abra o Claude Code e execute ${cyan}/sincron-auto${reset}.
+
+  ${cyan}Comando disponível:${reset}
+    /sincron-auto  - Iniciar workflow de automação multi-agente
+
+  ${cyan}Dica:${reset} Sincron-Auto funciona junto com Sincron-Plan!
+  Use /sincron-plan para planejar e /sincron-auto para executar.
+
+  ${cyan}Documentação:${reset} https://github.com/MLTCorp/sincron-auto
+`);
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation() {
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Terminal não-interativo detectado, usando instalação global${reset}\n`);
+    install(true);
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  let answered = false;
+
+  rl.on('close', () => {
+    if (!answered) {
+      answered = true;
+      console.log(`\n  ${yellow}Instalação cancelada${reset}\n`);
+      process.exit(0);
+    }
+  });
+
+  const globalPath = getGlobalDir(explicitConfigDir).replace(os.homedir(), '~');
+
+  console.log(`  ${yellow}Onde você quer instalar?${reset}
+
+  ${cyan}1${reset}) Global ${dim}(${globalPath})${reset} - disponível em todos os projetos
+  ${cyan}2${reset}) Local  ${dim}(./.claude)${reset} - apenas neste projeto
+`);
+
+  rl.question(`  Escolha ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
+    rl.close();
+    const choice = answer.trim() || '1';
+    const isGlobal = choice !== '2';
+    install(isGlobal);
+  });
+}
+
+// Main
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Não é possível especificar --global e --local juntos${reset}`);
+  process.exit(1);
+} else if (explicitConfigDir && hasLocal) {
+  console.error(`  ${yellow}Não é possível usar --config-dir com --local${reset}`);
+  process.exit(1);
+} else if (hasUninstall) {
+  if (!hasGlobal && !hasLocal) {
+    console.error(`  ${yellow}--uninstall requer --global ou --local${reset}`);
+    console.error(`  Exemplo: npx sincron-auto --global --uninstall`);
+    process.exit(1);
+  }
+  uninstall(hasGlobal);
+} else if (hasGlobal || hasLocal) {
+  install(hasGlobal);
+} else {
+  promptLocation();
+}