aris-mac-cleaner 2.0.0 → 3.0.0

package/bin/cli.js

@@ -1,34 +1,258 @@
 #!/usr/bin/env node
 
+// ╔══════════════════════════════════════════════════════════════════════════════╗
+// ║                         ARIS MAC CLEANER v3.0                                ║
+// ║                           por Salvador Reis                                  ║
+// ╚══════════════════════════════════════════════════════════════════════════════╝
+
 const { execSync, spawnSync } = require('child_process');
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
+const readline = require('readline');
+const crypto = require('crypto');
+
+const VERSION = '3.0';
+const HOME = os.homedir();
+const CONFIG_DIR = path.join(HOME, '.aris-mac-cleaner');
+const HISTORY_FILE = path.join(CONFIG_DIR, 'history.log');
+const EXCLUSIONS_FILE = path.join(CONFIG_DIR, 'exclusions.conf');
+const CUSTOM_PATHS_FILE = path.join(CONFIG_DIR, 'custom-paths.conf');
+const LANGUAGE_FILE = path.join(CONFIG_DIR, 'language');
+
+// Create config directory
+if (!fs.existsSync(CONFIG_DIR)) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// COLORS AND SYMBOLS
+// ══════════════════════════════════════════════════════════════════════════════
 
-// Cores
-const colors = {
+const c = {
   reset: '\x1b[0m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m'
+  red: '\x1b[0;31m',
+  green: '\x1b[0;32m',
+  yellow: '\x1b[1;33m',
+  blue: '\x1b[0;34m',
+  cyan: '\x1b[0;36m',
+  white: '\x1b[1;37m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m'
 };
 
-const c = colors;
+const CHECK = '✓';
+const CROSS = '✗';
+const ARROW = '→';
+const BULLET = '•';
 
-// Verificar se é macOS
-if (os.platform() !== 'darwin') {
-  console.log(`${c.red}Este programa só funciona em macOS${c.reset}`);
-  process.exit(1);
+// ══════════════════════════════════════════════════════════════════════════════
+// MULTI-LANGUAGE
+// ══════════════════════════════════════════════════════════════════════════════
+
+let LANG_CODE = 'pt';
+if (fs.existsSync(LANGUAGE_FILE)) {
+  LANG_CODE = fs.readFileSync(LANGUAGE_FILE, 'utf8').trim();
 }
 
-const HOME = os.homedir();
+const MSG = LANG_CODE === 'pt' ? {
+  WELCOME: 'Bem-vindo ao Aris Mac Cleaner',
+  MENU_TITLE: 'MENU PRINCIPAL',
+  OPT_QUICK: 'Limpeza Rápida (caches e temporários)',
+  OPT_LARGE: 'Encontrar Ficheiros Grandes (>100MB)',
+  OPT_DUPLICATES: 'Encontrar Duplicados',
+  OPT_APPS: 'Desinstalar Aplicações',
+  OPT_STARTUP: 'Gerir Apps de Arranque',
+  OPT_BROWSERS: 'Limpar Browsers',
+  OPT_PROCESSES: 'Matar Processos Pesados',
+  OPT_STATS: 'Ver Estatísticas',
+  OPT_SETTINGS: 'Configurações',
+  OPT_EXIT: 'Sair',
+  CHOOSE: 'Escolha',
+  INVALID: 'Opção inválida',
+  PRESS_ENTER: 'Pressiona ENTER para continuar',
+  SCANNING: 'A analisar...',
+  FOUND: 'Encontrado',
+  TOTAL: 'Total',
+  DELETE: 'Apagar',
+  KEEP: 'Manter',
+  CANCEL: 'Cancelar',
+  CONFIRM: 'Confirmar',
+  FREED: 'Libertado',
+  AVAILABLE: 'Disponível',
+  HEALTH_SCORE: 'Health Score',
+  EXCELLENT: 'Excelente',
+  GOOD: 'Bom',
+  ATTENTION: 'Atenção',
+  CRITICAL: 'Crítico',
+  DIAGNOSE: 'DIAGNÓSTICO DO SISTEMA',
+  DISK: 'Disco',
+  RAM: 'RAM',
+  SWAP: 'Swap',
+  CPU: 'CPU',
+  IN_USE: 'em uso',
+  FREE_OF: 'livres de',
+  SELECT_DELETE: 'Seleciona para apagar',
+  SELECT_KEEP: 'Seleciona para manter',
+  ALL: 'todos',
+  NONE: 'nenhum',
+  BACK: 'Voltar',
+  FINAL_REPORT: 'RELATÓRIO FINAL',
+  READY: 'Pronto para trabalhar!',
+  RESTART_REC: 'Recomendação: Reinicia o Mac para limpar memória',
+  NO_ITEMS: 'Nada encontrado',
+  CLEANING: 'A limpar...',
+  CATEGORIES: 'CATEGORIAS',
+  SYSTEM_CACHES: 'Caches do Sistema',
+  DEV_TOOLS: 'Ferramentas de Dev',
+  BROWSERS_CAT: 'Browsers',
+  DOWNLOADS_CAT: 'Downloads',
+  APPS_CAT: 'Aplicações',
+  PROCESS_MEM: 'Por Memória',
+  PROCESS_CPU: 'Por CPU',
+  KILL: 'Matar',
+  STARTUP_ITEMS: 'Items de Arranque',
+  LAUNCH_AGENTS: 'Launch Agents',
+  ENABLED: 'Ativo',
+  DISABLED: 'Desativado',
+  TOGGLE: 'Alternar',
+  DISABLE_ALL: 'Desativar todos',
+  THIS_MONTH: 'Este mês',
+  CLEANINGS: 'Limpezas',
+  AVG_SCORE: 'Score médio',
+  HISTORY: 'Histórico',
+  EXCLUSIONS: 'Gerir Exclusões',
+  CUSTOM_PATHS: 'Caminhos Personalizados',
+  CHANGE_LANG: 'Mudar Idioma',
+  RESET_DEFAULTS: 'Repor Predefinições',
+  PREVIEW_MODE: 'Modo Preview (não apaga nada)',
+  LARGE_FILES: 'FICHEIROS GRANDES',
+  DUPLICATES: 'FICHEIROS DUPLICADOS',
+  UNINSTALL: 'DESINSTALAR APLICAÇÕES',
+  APP_SIZE: 'app',
+  DATA_SIZE: 'dados',
+  CURRENT_EXCLUSIONS: 'Exclusões atuais',
+  CURRENT_PATHS: 'Caminhos personalizados atuais',
+  ENTER_PATH: 'Introduz caminho (c=limpar, n=voltar)',
+  PATH: 'Caminho',
+  CLEARED: 'Limpo',
+  ADDED: 'Adicionado',
+  LANG_CHANGED_EN: 'Language changed to English',
+  LANG_CHANGED_PT: 'Idioma alterado para Português',
+  SETTINGS_RESET: 'Configurações repostas',
+  REMOVED: 'Removido',
+  NEED_SUDO: 'Precisa sudo para remover app. Executa:',
+  DELETING: 'A apagar',
+  KILLED: 'Morto',
+  FAILED_KILL: 'Falhou ao matar',
+  NO_HISTORY: 'Sem histórico. Faz algumas limpezas primeiro!',
+  FEATURE_PROGRESS: 'Funcionalidade em progresso...',
+  GROUP: 'Grupo',
+  EACH: 'cada',
+  IN_DUPLICATES: 'em duplicados',
+  HASHING: 'A calcular hashes...'
+} : {
+  WELCOME: 'Welcome to Aris Mac Cleaner',
+  MENU_TITLE: 'MAIN MENU',
+  OPT_QUICK: 'Quick Clean (caches and temp files)',
+  OPT_LARGE: 'Find Large Files (>100MB)',
+  OPT_DUPLICATES: 'Find Duplicates',
+  OPT_APPS: 'Uninstall Applications',
+  OPT_STARTUP: 'Manage Startup Apps',
+  OPT_BROWSERS: 'Clean Browsers',
+  OPT_PROCESSES: 'Kill Heavy Processes',
+  OPT_STATS: 'View Statistics',
+  OPT_SETTINGS: 'Settings',
+  OPT_EXIT: 'Exit',
+  CHOOSE: 'Choose',
+  INVALID: 'Invalid option',
+  PRESS_ENTER: 'Press ENTER to continue',
+  SCANNING: 'Scanning...',
+  FOUND: 'Found',
+  TOTAL: 'Total',
+  DELETE: 'Delete',
+  KEEP: 'Keep',
+  CANCEL: 'Cancel',
+  CONFIRM: 'Confirm',
+  FREED: 'Freed',
+  AVAILABLE: 'Available',
+  HEALTH_SCORE: 'Health Score',
+  EXCELLENT: 'Excellent',
+  GOOD: 'Good',
+  ATTENTION: 'Warning',
+  CRITICAL: 'Critical',
+  DIAGNOSE: 'SYSTEM DIAGNOSTICS',
+  DISK: 'Disk',
+  RAM: 'RAM',
+  SWAP: 'Swap',
+  CPU: 'CPU',
+  IN_USE: 'in use',
+  FREE_OF: 'free of',
+  SELECT_DELETE: 'Select to delete',
+  SELECT_KEEP: 'Select to keep',
+  ALL: 'all',
+  NONE: 'none',
+  BACK: 'Back',
+  FINAL_REPORT: 'FINAL REPORT',
+  READY: 'Ready to work!',
+  RESTART_REC: 'Recommendation: Restart Mac to clear memory',
+  NO_ITEMS: 'Nothing found',
+  CLEANING: 'Cleaning...',
+  CATEGORIES: 'CATEGORIES',
+  SYSTEM_CACHES: 'System Caches',
+  DEV_TOOLS: 'Dev Tools',
+  BROWSERS_CAT: 'Browsers',
+  DOWNLOADS_CAT: 'Downloads',
+  APPS_CAT: 'Applications',
+  PROCESS_MEM: 'By Memory',
+  PROCESS_CPU: 'By CPU',
+  KILL: 'Kill',
+  STARTUP_ITEMS: 'Login Items',
+  LAUNCH_AGENTS: 'Launch Agents',
+  ENABLED: 'Enabled',
+  DISABLED: 'Disabled',
+  TOGGLE: 'Toggle',
+  DISABLE_ALL: 'Disable all',
+  THIS_MONTH: 'This month',
+  CLEANINGS: 'Cleanings',
+  AVG_SCORE: 'Avg score',
+  HISTORY: 'History',
+  EXCLUSIONS: 'Manage Exclusions',
+  CUSTOM_PATHS: 'Custom Paths',
+  CHANGE_LANG: 'Change Language',
+  RESET_DEFAULTS: 'Reset Defaults',
+  PREVIEW_MODE: 'Preview Mode (doesn\'t delete)',
+  LARGE_FILES: 'LARGE FILES',
+  DUPLICATES: 'DUPLICATE FILES',
+  UNINSTALL: 'UNINSTALL APPLICATIONS',
+  APP_SIZE: 'app',
+  DATA_SIZE: 'data',
+  CURRENT_EXCLUSIONS: 'Current exclusions',
+  CURRENT_PATHS: 'Current custom paths',
+  ENTER_PATH: 'Enter path (c=clear, n=back)',
+  PATH: 'Path',
+  CLEARED: 'Cleared',
+  ADDED: 'Added',
+  LANG_CHANGED_EN: 'Language changed to English',
+  LANG_CHANGED_PT: 'Idioma alterado para Português',
+  SETTINGS_RESET: 'Settings reset to defaults',
+  REMOVED: 'Removed',
+  NEED_SUDO: 'Need sudo to remove app. Run:',
+  DELETING: 'Deleting',
+  KILLED: 'Killed',
+  FAILED_KILL: 'Failed to kill',
+  NO_HISTORY: 'No history yet. Run some cleanups first!',
+  FEATURE_PROGRESS: 'Feature in progress...',
+  GROUP: 'Group',
+  EACH: 'each',
+  IN_DUPLICATES: 'in duplicates',
+  HASHING: 'Calculating hashes...'
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+// UTILITY FUNCTIONS
+// ══════════════════════════════════════════════════════════════════════════════
 
-// Função para executar comandos
 function exec(cmd) {
   try {
     return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
@@ -37,211 +261,1151 @@ function exec(cmd) {
   }
 }
 
-// Função para obter tamanho de pasta
-function getSize(path) {
+function getSize(p) {
+  const fullPath = p.replace(/^~/, HOME);
   try {
-    const result = exec(`du -sm "${path}" 2>/dev/null`);
+    if (!fs.existsSync(fullPath)) return 0;
+    const result = exec(`du -sm "${fullPath}" 2>/dev/null`);
     return parseInt(result.split('\t')[0]) || 0;
   } catch (e) {
     return 0;
   }
 }
 
-// Função para limpar pasta
-function cleanPath(p, name) {
-  const fullPath = p.replace('~', HOME);
-  if (fs.existsSync(fullPath)) {
+function formatSize(sizeMB) {
+  if (sizeMB >= 1024) {
+    return `${(sizeMB / 1024).toFixed(1)} GB`;
+  }
+  return `${sizeMB} MB`;
+}
+
+function isExcluded(p) {
+  if (!fs.existsSync(EXCLUSIONS_FILE)) return false;
+  const exclusions = fs.readFileSync(EXCLUSIONS_FILE, 'utf8').split('\n').filter(l => l.trim());
+  return exclusions.some(ex => p.includes(ex));
+}
+
+function logCleanup(freed, score) {
+  const line = `${new Date().toISOString().slice(0, 16).replace('T', ' ')} | ${MSG.FREED}: ${freed} MB | Score: ${score}/100\n`;
+  fs.appendFileSync(HISTORY_FILE, line);
+}
+
+function clearScreen() {
+  process.stdout.write('\x1b[2J\x1b[H');
+}
+
+function header() {
+  clearScreen();
+  const date = new Date().toLocaleDateString('en-GB', {
+    weekday: 'long', day: '2-digit', month: 'long', year: 'numeric'
+  });
+  const time = new Date().toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+
+  console.log();
+  console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════╗${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}${c.white}                    ARIS MAC CLEANER v${VERSION}                        ${c.reset}${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}${c.dim}                  ${date} ${BULLET} ${time}                   ${c.reset}${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════╝${c.reset}`);
+  console.log();
+}
+
+function sectionHeader(title) {
+  console.log(`${c.white}┌─────────────────────────────────────────────────────────────────┐${c.reset}`);
+  console.log(`${c.white}│${c.reset}  ${c.blue}▶ ${title}${c.reset}`);
+  console.log(`${c.white}└─────────────────────────────────────────────────────────────────┘${c.reset}`);
+  console.log();
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function pressEnter() {
+  console.log();
+  await prompt(`  ${c.dim}${MSG.PRESS_ENTER}...${c.reset} `);
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// SYSTEM DIAGNOSTICS
+// ══════════════════════════════════════════════════════════════════════════════
+
+let systemStats = {};
+
+function getSystemStats() {
+  // Disk
+  const diskInfo = exec("df -h / | tail -1").split(/\s+/);
+  const diskRaw = exec("df / | tail -1").split(/\s+/);
+  systemStats.diskTotal = diskInfo[1]?.replace('Gi', '') || '0';
+  systemStats.diskFree = diskInfo[3]?.replace('Gi', '') || '0';
+  systemStats.diskPercent = parseInt(diskInfo[4]) || 0;
+  systemStats.diskFreeBlocks = parseInt(diskRaw[3]) || 0;
+
+  if (systemStats.diskPercent < 50) {
+    systemStats.diskStatus = `${c.green}${CHECK} ${MSG.EXCELLENT}${c.reset}`;
+  } else if (systemStats.diskPercent < 80) {
+    systemStats.diskStatus = `${c.yellow}! ${MSG.ATTENTION}${c.reset}`;
+  } else {
+    systemStats.diskStatus = `${c.red}${CROSS} ${MSG.CRITICAL}${c.reset}`;
+  }
+
+  // RAM
+  const ramFreePercent = parseInt(exec("memory_pressure 2>/dev/null | grep 'System-wide' | awk '{print $5}'")) || 50;
+  systemStats.ramUsedPercent = 100 - ramFreePercent;
+
+  if (systemStats.ramUsedPercent < 70) {
+    systemStats.ramStatus = `${c.green}${CHECK} OK${c.reset}`;
+  } else if (systemStats.ramUsedPercent < 90) {
+    systemStats.ramStatus = `${c.yellow}! ${MSG.ATTENTION}${c.reset}`;
+  } else {
+    systemStats.ramStatus = `${c.red}${CROSS} ${MSG.CRITICAL}${c.reset}`;
+  }
+
+  // Swap
+  const swapStr = exec("sysctl vm.swapusage 2>/dev/null | awk '{print $7}'");
+  systemStats.swapUsed = parseInt(swapStr) || 0;
+
+  if (systemStats.swapUsed < 2000) {
+    systemStats.swapStatus = `${c.green}${CHECK} OK${c.reset}`;
+  } else if (systemStats.swapUsed < 8000) {
+    systemStats.swapStatus = `${c.yellow}! Alto${c.reset}`;
+  } else {
+    systemStats.swapStatus = `${c.red}${CROSS} ${MSG.CRITICAL}${c.reset}`;
+  }
+
+  // CPU
+  const cpuIdle = parseFloat(exec("top -l 1 2>/dev/null | grep 'CPU usage' | awk '{print $7}'")) || 50;
+  systemStats.cpuUsed = Math.round(100 - cpuIdle);
+
+  if (systemStats.cpuUsed < 50) {
+    systemStats.cpuStatus = `${c.green}${CHECK} OK${c.reset}`;
+  } else if (systemStats.cpuUsed < 80) {
+    systemStats.cpuStatus = `${c.yellow}! ${MSG.ATTENTION}${c.reset}`;
+  } else {
+    systemStats.cpuStatus = `${c.red}${CROSS} ${MSG.CRITICAL}${c.reset}`;
+  }
+}
+
+function showDiagnostics() {
+  sectionHeader(MSG.DIAGNOSE);
+  console.log(`  ${BULLET} ${c.white}${MSG.DISK}${c.reset}      ${systemStats.diskFree}GB ${MSG.FREE_OF} ${systemStats.diskTotal}GB    ${systemStats.diskStatus}`);
+  console.log(`  ${BULLET} ${c.white}${MSG.RAM}${c.reset}        ${systemStats.ramUsedPercent}% ${MSG.IN_USE}                  ${systemStats.ramStatus}`);
+  console.log(`  ${BULLET} ${c.white}${MSG.SWAP}${c.reset}       ${systemStats.swapUsed}MB ${MSG.IN_USE}               ${systemStats.swapStatus}`);
+  console.log(`  ${BULLET} ${c.white}${MSG.CPU}${c.reset}        ${systemStats.cpuUsed}% ${MSG.IN_USE}                 ${systemStats.cpuStatus}`);
+  console.log();
+}
+
+function calculateHealthScore() {
+  let score = 100;
+  if (systemStats.diskPercent > 80) score -= 30;
+  else if (systemStats.diskPercent > 60) score -= 10;
+  if (systemStats.ramUsedPercent > 90) score -= 30;
+  else if (systemStats.ramUsedPercent > 70) score -= 10;
+  if (systemStats.swapUsed > 8000) score -= 20;
+  else if (systemStats.swapUsed > 4000) score -= 10;
+
+  let color = c.green;
+  let text = MSG.EXCELLENT;
+  if (score < 60) { color = c.red; text = MSG.ATTENTION; }
+  else if (score < 80) { color = c.yellow; text = MSG.GOOD; }
+
+  return { score, color, text };
+}
+
+function showFinalReport(freed) {
+  const diskFreeAfter = exec("df -h / | tail -1").split(/\s+/)[3];
+  const health = calculateHealthScore();
+
+  console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════╗${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}${c.white}                         ${MSG.FINAL_REPORT}                          ${c.reset}${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}╠══════════════════════════════════════════════════════════════════╣${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}                                                                  ${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}   ${c.white}${MSG.DISK}${c.reset}                                                         ${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}   ${ARROW} ${MSG.AVAILABLE}: ${c.green}${diskFreeAfter}${c.reset}                                       ${c.cyan}║${c.reset}`);
+  if (freed > 0) {
+    console.log(`${c.cyan}║${c.reset}   ${ARROW} ${MSG.FREED}:  ${c.green}+${formatSize(freed)}${c.reset}                                     ${c.cyan}║${c.reset}`);
+  }
+  console.log(`${c.cyan}║${c.reset}                                                                  ${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}   ${c.white}${MSG.HEALTH_SCORE}${c.reset}                                                  ${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}   ${ARROW} ${health.color}${health.score}/100 - ${health.text}${c.reset}                                       ${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}║${c.reset}                                                                  ${c.cyan}║${c.reset}`);
+  console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════╝${c.reset}`);
+  console.log();
+
+  if (systemStats.swapUsed > 5000 || systemStats.ramUsedPercent > 85) {
+    console.log(`${c.yellow}⚠ ${MSG.RESTART_REC}${c.reset}`);
+    console.log();
+  }
+
+  console.log(`${c.green}${CHECK} ${MSG.READY}${c.reset}`);
+
+  logCleanup(freed, health.score);
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 1: QUICK CLEAN
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function quickClean() {
+  header();
+  getSystemStats();
+  showDiagnostics();
+  sectionHeader(MSG.CATEGORIES);
+
+  const items = [];
+  let totalSize = 0;
+
+  function addItem(p, name, category) {
+    const fullPath = p.replace(/^~/, HOME);
+    if (isExcluded(fullPath)) return;
+
+    const size = getSize(p);
+    if (size > 0) {
+      items.push({ path: fullPath, name, category, size, selected: true });
+      totalSize += size;
+    }
+  }
+
+  // System Caches
+  addItem('~/Library/Caches/Google', 'Google/Chrome Cache', 'system');
+  addItem('~/Library/Caches/com.spotify.client', 'Spotify Cache', 'system');
+  addItem('~/Library/Caches/com.apple.Safari', 'Safari Cache', 'system');
+  addItem('~/Library/Logs', 'System Logs', 'system');
+
+  // Dev Tools
+  addItem('~/Library/Caches/CocoaPods', 'CocoaPods Cache', 'dev');
+  addItem('~/Library/Caches/Homebrew', 'Homebrew Cache', 'dev');
+  addItem('~/Library/Caches/typescript', 'TypeScript Cache', 'dev');
+  addItem('~/Library/Caches/node-gyp', 'Node-gyp Cache', 'dev');
+  addItem('~/Library/Caches/pip', 'Pip Cache', 'dev');
+  addItem('~/Library/Caches/yarn', 'Yarn Cache', 'dev');
+  addItem('~/Library/Caches/pnpm', 'pnpm Cache', 'dev');
+  addItem('~/.npm', 'npm Cache', 'dev');
+  addItem('~/Library/Application Support/Code/User/workspaceStorage', 'VS Code Workspace', 'dev');
+  addItem('~/Library/Developer/Xcode/DerivedData', 'Xcode DerivedData', 'dev');
+
+  // Browsers
+  addItem('~/Library/Application Support/Google/GoogleUpdater/crx_cache', 'Google Updater', 'browsers');
+  addItem('~/Library/Application Support/Google/Chrome/component_crx_cache', 'Chrome Components', 'browsers');
+
+  // Claude versions
+  const claudeVersionsPath = path.join(HOME, '.local/share/claude/versions');
+  if (fs.existsSync(claudeVersionsPath)) {
     try {
-      execSync(`rm -rf "${fullPath}"`, { stdio: 'ignore' });
-      console.log(`  ${c.green}✓${c.reset} ${name}`);
-      return true;
-    } catch (e) {
-      return false;
+      const versions = fs.readdirSync(claudeVersionsPath).sort().reverse();
+      if (versions.length > 1) {
+        let claudeSize = 0;
+        versions.slice(1).forEach(v => {
+          claudeSize += getSize(path.join(claudeVersionsPath, v));
+        });
+        if (claudeSize > 0) {
+          items.push({
+            path: 'CLAUDE_VERSIONS',
+            name: `Claude (${versions.length - 1} old versions)`,
+            category: 'apps',
+            size: claudeSize,
+            selected: true
+          });
+          totalSize += claudeSize;
+        }
+      }
+    } catch (e) {}
+  }
+
+  // Old Downloads
+  const dmgCount = parseInt(exec('find ~/Downloads -name "*.dmg" -mtime +7 2>/dev/null | wc -l')) || 0;
+  const zipCount = parseInt(exec('find ~/Downloads -name "*.zip" -mtime +30 2>/dev/null | wc -l')) || 0;
+  if (dmgCount > 0 || zipCount > 0) {
+    const dlSize = parseInt(exec('find ~/Downloads \\( -name "*.dmg" -mtime +7 -o -name "*.zip" -mtime +30 \\) -exec du -sm {} \\; 2>/dev/null | awk \'{sum+=$1} END {print sum}\'')) || 0;
+    if (dlSize > 0) {
+      items.push({
+        path: 'OLD_DOWNLOADS',
+        name: `Old Downloads (${dmgCount} dmg, ${zipCount} zip)`,
+        category: 'downloads',
+        size: dlSize,
+        selected: true
+      });
+      totalSize += dlSize;
     }
   }
-  return false;
-}
-
-// Limpar consola
-console.clear();
-
-// Header
-console.log();
-console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════╗${c.reset}`);
-console.log(`${c.cyan}║${c.reset}${c.bold}${c.white}                    ARIS MAC CLEANER v2.0                       ${c.reset}${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}║${c.reset}${c.dim}                     por Salvador Reis                           ${c.reset}${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════╝${c.reset}`);
-console.log();
-
-// FASE 1: DIAGNÓSTICO
-console.log(`${c.white}┌─────────────────────────────────────────────────────────────────┐${c.reset}`);
-console.log(`${c.white}│${c.reset}  ${c.blue}▶ FASE 1: DIAGNÓSTICO DO SISTEMA${c.reset}                               ${c.white}│${c.reset}`);
-console.log(`${c.white}└─────────────────────────────────────────────────────────────────┘${c.reset}`);
-console.log();
-
-// Disco
-const diskInfo = exec("df -h / | tail -1").split(/\s+/);
-const diskTotal = diskInfo[1];
-const diskUsed = diskInfo[2];
-const diskFree = diskInfo[3];
-const diskPercent = parseInt(diskInfo[4]);
-const diskFreeBefore = parseInt(exec("df / | tail -1").split(/\s+/)[3]);
-
-let diskStatus = `${c.green}✓ Excelente${c.reset}`;
-if (diskPercent >= 80) diskStatus = `${c.red}✗ Crítico${c.reset}`;
-else if (diskPercent >= 50) diskStatus = `${c.yellow}! Atenção${c.reset}`;
-
-// RAM
-const ramFreePercent = parseInt(exec("memory_pressure 2>/dev/null | grep 'System-wide' | awk '{print $5}'")) || 50;
-const ramUsedPercent = 100 - ramFreePercent;
-
-let ramStatus = `${c.green}✓ OK${c.reset}`;
-if (ramUsedPercent >= 90) ramStatus = `${c.red}✗ Crítico${c.reset}`;
-else if (ramUsedPercent >= 70) ramStatus = `${c.yellow}! Pressão${c.reset}`;
-
-// Swap
-const swapUsed = parseInt(exec("sysctl vm.swapusage 2>/dev/null | awk '{print int($7)}'")) || 0;
-
-let swapStatus = `${c.green}✓ OK${c.reset}`;
-if (swapUsed >= 8000) swapStatus = `${c.red}✗ Crítico${c.reset}`;
-else if (swapUsed >= 2000) swapStatus = `${c.yellow}! Alto${c.reset}`;
-
-// CPU
-const cpuIdle = parseFloat(exec("top -l 1 | grep 'CPU usage' | awk '{print $7}'")) || 50;
-const cpuUsed = Math.round(100 - cpuIdle);
-
-let cpuStatus = `${c.green}✓ OK${c.reset}`;
-if (cpuUsed >= 80) cpuStatus = `${c.red}✗ Sobrecarregado${c.reset}`;
-else if (cpuUsed >= 50) cpuStatus = `${c.yellow}! Ocupado${c.reset}`;
-
-console.log(`  • ${c.bold}Disco${c.reset}      ${diskFree} livres de ${diskTotal}    ${diskStatus}`);
-console.log(`  • ${c.bold}RAM${c.reset}        ${ramUsedPercent}% em uso                  ${ramStatus}`);
-console.log(`  • ${c.bold}Swap${c.reset}       ${swapUsed}MB em uso               ${swapStatus}`);
-console.log(`  • ${c.bold}CPU${c.reset}        ${cpuUsed}% em uso                 ${cpuStatus}`);
-console.log();
-
-// FASE 2: ANÁLISE
-console.log(`${c.white}┌─────────────────────────────────────────────────────────────────┐${c.reset}`);
-console.log(`${c.white}│${c.reset}  ${c.blue}▶ FASE 2: ANÁLISE DE LIMPEZA${c.reset}                                   ${c.white}│${c.reset}`);
-console.log(`${c.white}└─────────────────────────────────────────────────────────────────┘${c.reset}`);
-console.log();
-
-const cleanPaths = [
-  { path: `${HOME}/Library/Caches/Google`, name: 'Google Cache' },
-  { path: `${HOME}/Library/Caches/com.spotify.client`, name: 'Spotify Cache' },
-  { path: `${HOME}/Library/Caches/CocoaPods`, name: 'CocoaPods Cache' },
-  { path: `${HOME}/Library/Caches/Homebrew`, name: 'Homebrew Cache' },
-  { path: `${HOME}/Library/Caches/typescript`, name: 'TypeScript Cache' },
-  { path: `${HOME}/Library/Caches/node-gyp`, name: 'Node-gyp Cache' },
-  { path: `${HOME}/Library/Caches/pip`, name: 'Pip Cache' },
-  { path: `${HOME}/Library/Caches/yarn`, name: 'Yarn Cache' },
-  { path: `${HOME}/Library/Caches/pnpm`, name: 'pnpm Cache' },
-  { path: `${HOME}/.npm`, name: 'npm Cache' },
-  { path: `${HOME}/Library/Application Support/Code/User/workspaceStorage`, name: 'VS Code Storage' },
-  { path: `${HOME}/Library/Developer/Xcode/DerivedData`, name: 'Xcode DerivedData' },
-  { path: `${HOME}/Library/Application Support/Google/GoogleUpdater/crx_cache`, name: 'Google Updater' },
-  { path: `${HOME}/Library/Application Support/Google/Chrome/component_crx_cache`, name: 'Chrome Components' },
-];
-
-let totalClean = 0;
-
-cleanPaths.forEach(item => {
-  const size = getSize(item.path);
-  if (size > 0) {
-    totalClean += size;
-    console.log(`  • ${item.name.padEnd(25)} ${c.dim}${String(size).padStart(6)} MB${c.reset}`);
-  }
-});
-
-console.log();
-console.log(`  → ${c.bold}Total a libertar:${c.reset} ${c.green}~${Math.round(totalClean / 1024)} GB${c.reset} ${c.dim}(${totalClean} MB)${c.reset}`);
-console.log();
-
-// FASE 3: LIMPEZA
-console.log(`${c.white}┌─────────────────────────────────────────────────────────────────┐${c.reset}`);
-console.log(`${c.white}│${c.reset}  ${c.blue}▶ FASE 3: LIMPEZA EM PROGRESSO${c.reset}                                 ${c.white}│${c.reset}`);
-console.log(`${c.white}└─────────────────────────────────────────────────────────────────┘${c.reset}`);
-console.log();
-
-// npm cache
-try {
-  execSync('npm cache clean --force 2>/dev/null', { stdio: 'ignore' });
-  console.log(`  ${c.green}✓${c.reset} npm cache`);
-} catch (e) {}
-
-// Limpar paths
-cleanPaths.forEach(item => {
-  cleanPath(item.path, item.name);
-});
-
-// Claude versões antigas
-const claudeVersionsPath = `${HOME}/.local/share/claude/versions`;
-if (fs.existsSync(claudeVersionsPath)) {
-  try {
-    const versions = fs.readdirSync(claudeVersionsPath).sort().reverse();
-    if (versions.length > 1) {
+
+  // Custom paths
+  if (fs.existsSync(CUSTOM_PATHS_FILE)) {
+    const customPaths = fs.readFileSync(CUSTOM_PATHS_FILE, 'utf8').split('\n').filter(l => l.trim() && !l.startsWith('#'));
+    customPaths.forEach(cp => {
+      addItem(cp, `Custom: ${path.basename(cp)}`, 'custom');
+    });
+  }
+
+  if (items.length === 0) {
+    console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  // Show by category
+  function showCategory(catId, catName) {
+    const catItems = items.filter(i => i.category === catId);
+    if (catItems.length === 0) return;
+
+    const catSize = catItems.reduce((sum, i) => sum + i.size, 0);
+    console.log(`  ${c.white}📁 ${catName}${c.reset} ${c.dim}(${formatSize(catSize)})${c.reset}`);
+
+    catItems.forEach(item => {
+      const idx = items.indexOf(item) + 1;
+      console.log(`  ${c.cyan}[${String(idx).padStart(2)}]${c.reset} ${item.name.padEnd(35)} ${c.dim}${String(item.size).padStart(6)} MB${c.reset}`);
+    });
+    console.log();
+  }
+
+  showCategory('system', MSG.SYSTEM_CACHES);
+  showCategory('dev', MSG.DEV_TOOLS);
+  showCategory('browsers', MSG.BROWSERS_CAT);
+  showCategory('downloads', MSG.DOWNLOADS_CAT);
+  showCategory('apps', MSG.APPS_CAT);
+  showCategory('custom', 'Custom');
+
+  console.log(`  ${ARROW} ${c.white}${MSG.TOTAL}:${c.reset} ${c.green}${formatSize(totalSize)}${c.reset}`);
+  console.log();
+
+  // Selection
+  sectionHeader(MSG.SELECT_DELETE);
+  console.log(`  ${c.dim}a = ${MSG.ALL} | n = ${MSG.CANCEL} | 1,3,5 | 1-5 | 1-5,8,10${c.reset}`);
+  console.log();
+
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    console.log(`  ${c.yellow}${MSG.CANCEL}${c.reset}`);
+    await pressEnter();
+    return;
+  }
+
+  // Process selection
+  if (choice.toLowerCase() !== 'a') {
+    items.forEach(item => item.selected = false);
+
+    const parts = choice.split(',');
+    parts.forEach(part => {
+      part = part.trim();
+      if (part.includes('-')) {
+        const [start, end] = part.split('-').map(n => parseInt(n));
+        for (let j = start; j <= end; j++) {
+          if (j > 0 && j <= items.length) items[j - 1].selected = true;
+        }
+      } else {
+        const idx = parseInt(part) - 1;
+        if (idx >= 0 && idx < items.length) items[idx].selected = true;
+      }
+    });
+  }
+
+  // Clean
+  console.log();
+  sectionHeader(MSG.CLEANING);
+
+  let cleanedSize = 0;
+
+  for (const item of items) {
+    if (!item.selected) continue;
+
+    if (item.path === 'CLAUDE_VERSIONS') {
+      const versions = fs.readdirSync(claudeVersionsPath).sort().reverse();
       versions.slice(1).forEach(v => {
-        fs.rmSync(path.join(claudeVersionsPath, v), { recursive: true, force: true });
+        try {
+          fs.rmSync(path.join(claudeVersionsPath, v), { recursive: true, force: true });
+        } catch (e) {}
       });
-      console.log(`  ${c.green}✓${c.reset} Claude (${versions.length - 1} versões antigas)`);
+      console.log(`  ${c.green}${CHECK}${c.reset} ${item.name}`);
+      cleanedSize += item.size;
+    } else if (item.path === 'OLD_DOWNLOADS') {
+      exec('find ~/Downloads -name "*.dmg" -mtime +7 -delete 2>/dev/null');
+      exec('find ~/Downloads -name "*.zip" -mtime +30 -delete 2>/dev/null');
+      console.log(`  ${c.green}${CHECK}${c.reset} ${item.name}`);
+      cleanedSize += item.size;
+    } else if (fs.existsSync(item.path)) {
+      try {
+        fs.rmSync(item.path, { recursive: true, force: true });
+        console.log(`  ${c.green}${CHECK}${c.reset} ${item.name}`);
+        cleanedSize += item.size;
+      } catch (e) {}
     }
+  }
+
+  // npm cache
+  try {
+    execSync('npm cache clean --force 2>/dev/null', { stdio: 'ignore' });
   } catch (e) {}
+
+  console.log();
+  getSystemStats();
+  showFinalReport(cleanedSize);
+  await pressEnter();
 }
 
-// Downloads antigos
-try {
-  execSync('find ~/Downloads -name "*.dmg" -mtime +7 -delete 2>/dev/null', { stdio: 'ignore' });
-  execSync('find ~/Downloads -name "*.zip" -mtime +30 -delete 2>/dev/null', { stdio: 'ignore' });
-} catch (e) {}
-
-// Logs
-try {
-  execSync('rm -rf ~/Library/Logs/*.log 2>/dev/null', { stdio: 'ignore' });
-  console.log(`  ${c.green}✓${c.reset} Logs do sistema`);
-} catch (e) {}
-
-console.log();
-
-// FASE 4: RESULTADO
-const diskFreeAfter = parseInt(exec("df / | tail -1").split(/\s+/)[3]);
-const freed = Math.round((diskFreeAfter - diskFreeBefore) / 1024 / 1024);
-const diskFreeGBAfter = exec("df -h / | tail -1").split(/\s+/)[3];
-const diskPercentAfter = parseInt(exec("df / | tail -1").split(/\s+/)[4]);
-
-// Health Score
-let healthScore = 100;
-if (diskPercentAfter > 80) healthScore -= 30;
-else if (diskPercentAfter > 60) healthScore -= 10;
-if (ramUsedPercent > 90) healthScore -= 30;
-else if (ramUsedPercent > 70) healthScore -= 10;
-if (swapUsed > 8000) healthScore -= 20;
-else if (swapUsed > 4000) healthScore -= 10;
-
-let healthColor = c.green;
-let healthText = 'Excelente';
-if (healthScore < 60) { healthColor = c.red; healthText = 'Atenção'; }
-else if (healthScore < 80) { healthColor = c.yellow; healthText = 'Bom'; }
-
-console.log(`${c.cyan}╔══════════════════════════════════════════════════════════════════╗${c.reset}`);
-console.log(`${c.cyan}║${c.reset}${c.bold}${c.white}                         RELATÓRIO FINAL                          ${c.reset}${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}╠══════════════════════════════════════════════════════════════════╣${c.reset}`);
-console.log(`${c.cyan}║${c.reset}                                                                  ${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}║${c.reset}   ${c.bold}Disco${c.reset}                                                         ${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}║${c.reset}   → Disponível: ${c.green}${diskFreeGBAfter}${c.reset}                                       ${c.cyan}║${c.reset}`);
-if (freed > 0) {
-console.log(`${c.cyan}║${c.reset}   → Libertado:  ${c.green}+${freed} GB${c.reset}                                        ${c.cyan}║${c.reset}`);
-}
-console.log(`${c.cyan}║${c.reset}                                                                  ${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}║${c.reset}   ${c.bold}Health Score${c.reset}                                                  ${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}║${c.reset}   → ${healthColor}${healthScore}/100 - ${healthText}${c.reset}                                       ${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}║${c.reset}                                                                  ${c.cyan}║${c.reset}`);
-console.log(`${c.cyan}╚══════════════════════════════════════════════════════════════════╝${c.reset}`);
-console.log();
-
-if (swapUsed > 5000 || ramUsedPercent > 85) {
-  console.log(`${c.yellow}⚠ Recomendação: Reinicia o Mac para limpar memória${c.reset}`);
-  console.log();
-}
-
-console.log(`${c.green}✓ Pronto para trabalhar!${c.reset}`);
-console.log();
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 2: LARGE FILES
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function findLargeFiles() {
+  header();
+  sectionHeader(`${MSG.LARGE_FILES} (>100MB)`);
+
+  console.log(`  ${c.dim}${MSG.SCANNING}${c.reset}`);
+  console.log();
+
+  const files = [];
+
+  const output = exec(`find ~ -type f -size +100M 2>/dev/null | head -50 | xargs -I {} du -m {} 2>/dev/null | sort -rn | head -30`);
+
+  output.split('\n').filter(l => l.trim()).forEach(line => {
+    const match = line.match(/^\s*(\d+)\s+(.+)$/);
+    if (!match) return;
+
+    const size = parseInt(match[1]);
+    const file = match[2];
+
+    // Skip system/protected paths
+    if (file.includes('/Library/Application Support/') ||
+        file.includes('/.Trash/') ||
+        file.includes('/node_modules/')) return;
+
+    files.push({ path: file, size });
+  });
+
+  if (files.length === 0) {
+    console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  header();
+  sectionHeader(`${MSG.LARGE_FILES} (>100MB)`);
+
+  const totalLarge = files.reduce((sum, f) => sum + f.size, 0);
+
+  files.forEach((file, i) => {
+    let displayFile = file.path.replace(HOME, '~');
+    if (displayFile.length > 50) {
+      displayFile = '...' + displayFile.slice(-47);
+    }
+    console.log(`  ${c.cyan}[${String(i + 1).padStart(2)}]${c.reset} ${c.dim}${String(file.size).padStart(6)} MB${c.reset}  ${displayFile}`);
+  });
+
+  console.log();
+  console.log(`  ${ARROW} ${c.white}${MSG.TOTAL}:${c.reset} ${c.green}${formatSize(totalLarge)}${c.reset} ${c.dim}(${files.length} files)${c.reset}`);
+  console.log();
+
+  console.log(`  ${c.dim}${MSG.SELECT_DELETE} [numbers/a/n]:${c.reset}`);
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    await pressEnter();
+    return;
+  }
+
+  const selected = new Array(files.length).fill(false);
+
+  if (choice.toLowerCase() === 'a') {
+    selected.fill(true);
+  } else {
+    const parts = choice.split(',');
+    parts.forEach(part => {
+      part = part.trim();
+      if (part.includes('-')) {
+        const [start, end] = part.split('-').map(n => parseInt(n));
+        for (let j = start; j <= end; j++) {
+          if (j > 0 && j <= files.length) selected[j - 1] = true;
+        }
+      } else {
+        const idx = parseInt(part) - 1;
+        if (idx >= 0 && idx < files.length) selected[idx] = true;
+      }
+    });
+  }
+
+  let deletedSize = 0;
+  console.log();
+
+  for (let i = 0; i < files.length; i++) {
+    if (!selected[i]) continue;
+
+    try {
+      fs.unlinkSync(files[i].path);
+      console.log(`  ${c.green}${CHECK}${c.reset} Deleted: ${path.basename(files[i].path)}`);
+      deletedSize += files[i].size;
+    } catch (e) {}
+  }
+
+  console.log();
+  console.log(`  ${c.green}${MSG.FREED}: ${formatSize(deletedSize)}${c.reset}`);
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 3: FIND DUPLICATES
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function findDuplicates() {
+  header();
+  sectionHeader(MSG.DUPLICATES);
+
+  console.log(`  ${c.dim}${MSG.SCANNING} (this may take a while)...${c.reset}`);
+  console.log();
+
+  // Find files > 1MB, group by size
+  const sizeMap = new Map();
+
+  const output = exec(`find ~ -type f -size +1M 2>/dev/null | head -500`);
+  const files = output.split('\n').filter(l => l.trim());
+
+  files.forEach(file => {
+    try {
+      const stats = fs.statSync(file);
+      const size = stats.size;
+      if (!sizeMap.has(size)) sizeMap.set(size, []);
+      sizeMap.get(size).push(file);
+    } catch (e) {}
+  });
+
+  console.log(`  ${c.dim}${MSG.HASHING}${c.reset}`);
+
+  // Find duplicates by hash for files with same size
+  const hashGroups = new Map();
+
+  for (const [size, fileList] of sizeMap) {
+    if (fileList.length < 2) continue;
+
+    for (const file of fileList) {
+      try {
+        const hash = exec(`md5 -q "${file}" 2>/dev/null`);
+        if (hash) {
+          if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+          hashGroups.get(hash).push(file);
+        }
+      } catch (e) {}
+    }
+  }
+
+  // Display duplicate groups
+  header();
+  sectionHeader(MSG.DUPLICATES);
+
+  let groupNum = 0;
+  let totalDupSize = 0;
+  const allDups = [];
+
+  for (const [hash, fileList] of hashGroups) {
+    if (fileList.length < 2) continue;
+
+    groupNum++;
+    const fileSize = Math.round(getSize(fileList[0]));
+    const dupSpace = (fileList.length - 1) * fileSize;
+    totalDupSize += dupSpace;
+
+    console.log(`  ${c.white}${MSG.GROUP} ${groupNum}${c.reset} ${c.dim}(${fileSize} MB ${MSG.EACH})${c.reset}`);
+
+    fileList.forEach((file, idx) => {
+      let display = file.replace(HOME, '~');
+      if (display.length > 50) display = '...' + display.slice(-47);
+      console.log(`    ${c.cyan}[${idx + 1}]${c.reset} ${display}`);
+      allDups.push(file);
+    });
+    console.log();
+
+    if (groupNum >= 10) break;
+  }
+
+  if (groupNum === 0) {
+    console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log(`  ${ARROW} ${c.white}${MSG.TOTAL}:${c.reset} ${c.green}${formatSize(totalDupSize)}${c.reset} ${MSG.IN_DUPLICATES}`);
+  console.log();
+  console.log(`  ${c.dim}${MSG.SELECT_KEEP}${c.reset}`);
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  console.log(`  ${c.yellow}${MSG.FEATURE_PROGRESS}${c.reset}`);
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 4: UNINSTALL APPS
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function uninstallApps() {
+  header();
+  sectionHeader(MSG.UNINSTALL);
+
+  console.log(`  ${c.dim}${MSG.SCANNING}${c.reset}`);
+
+  const apps = [];
+
+  const appDirs = fs.readdirSync('/Applications').filter(f => f.endsWith('.app'));
+
+  for (const appDir of appDirs) {
+    const appPath = path.join('/Applications', appDir);
+    const appName = appDir.replace('.app', '');
+
+    const appSize = getSize(appPath);
+
+    // Find associated data
+    let dataSize = 0;
+    let bundleId = '';
+
+    try {
+      bundleId = exec(`defaults read "${appPath}/Contents/Info" CFBundleIdentifier 2>/dev/null`);
+    } catch (e) {}
+
+    if (bundleId) {
+      const dataPaths = [
+        path.join(HOME, 'Library/Application Support', appName),
+        path.join(HOME, 'Library/Application Support', bundleId),
+        path.join(HOME, 'Library/Preferences', `${bundleId}.plist`),
+        path.join(HOME, 'Library/Caches', bundleId),
+        path.join(HOME, 'Library/Caches', appName),
+        path.join(HOME, 'Library/Containers', bundleId),
+        path.join(HOME, 'Library/Saved Application State', `${bundleId}.savedState`)
+      ];
+
+      dataPaths.forEach(dp => {
+        if (fs.existsSync(dp)) {
+          dataSize += getSize(dp);
+        }
+      });
+    }
+
+    const total = appSize + dataSize;
+    if (total < 50) continue;
+
+    apps.push({ name: appName, path: appPath, appSize, dataSize, bundleId });
+
+    if (apps.length >= 25) break;
+  }
+
+  header();
+  sectionHeader(MSG.UNINSTALL);
+
+  if (apps.length === 0) {
+    console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  apps.forEach((app, i) => {
+    console.log(`  ${c.cyan}[${String(i + 1).padStart(2)}]${c.reset} ${app.name.padEnd(25)} ${c.dim}(${String(app.appSize).padStart(3)} MB ${MSG.APP_SIZE} + ${String(app.dataSize).padStart(3)} MB ${MSG.DATA_SIZE})${c.reset}`);
+  });
+
+  console.log();
+  console.log(`  ${c.dim}${MSG.SELECT_DELETE} [numbers/n]:${c.reset}`);
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    await pressEnter();
+    return;
+  }
+
+  const parts = choice.split(',');
+  for (const part of parts) {
+    const idx = parseInt(part.trim()) - 1;
+    if (idx < 0 || idx >= apps.length) continue;
+
+    const app = apps[idx];
+    console.log(`  ${c.yellow}${MSG.DELETING} ${app.name}...${c.reset}`);
+
+    // Remove app data
+    if (app.bundleId) {
+      const dataPaths = [
+        path.join(HOME, 'Library/Application Support', app.name),
+        path.join(HOME, 'Library/Application Support', app.bundleId),
+        path.join(HOME, 'Library/Preferences', `${app.bundleId}.plist`),
+        path.join(HOME, 'Library/Caches', app.bundleId),
+        path.join(HOME, 'Library/Caches', app.name),
+        path.join(HOME, 'Library/Containers', app.bundleId),
+        path.join(HOME, 'Library/Saved Application State', `${app.bundleId}.savedState`),
+        path.join(HOME, 'Library/Logs', app.name)
+      ];
+
+      dataPaths.forEach(dp => {
+        try {
+          if (fs.existsSync(dp)) fs.rmSync(dp, { recursive: true, force: true });
+        } catch (e) {}
+      });
+    }
+
+    // Remove app
+    try {
+      fs.rmSync(app.path, { recursive: true, force: true });
+      console.log(`  ${c.green}${CHECK}${c.reset} ${app.name} ${MSG.REMOVED}`);
+    } catch (e) {
+      console.log(`  ${c.red}${MSG.NEED_SUDO}${c.reset}`);
+      console.log(`  ${c.dim}sudo rm -rf "${app.path}"${c.reset}`);
+    }
+  }
+
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 5: MANAGE STARTUP
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function manageStartup() {
+  header();
+  sectionHeader(MSG.STARTUP_ITEMS);
+
+  console.log(`  ${c.white}${MSG.STARTUP_ITEMS}:${c.reset}`);
+
+  // Get login items via AppleScript
+  const loginItems = exec(`osascript -e 'tell application "System Events" to get the name of every login item' 2>/dev/null`);
+
+  if (loginItems) {
+    const items = loginItems.split(', ').filter(i => i.trim());
+    items.forEach((item, idx) => {
+      console.log(`  ${c.cyan}[${idx + 1}]${c.reset} ${c.green}${CHECK}${c.reset} ${item} ${c.dim}(${MSG.ENABLED})${c.reset}`);
+    });
+  } else {
+    console.log(`  ${c.dim}No login items found${c.reset}`);
+  }
+
+  console.log();
+  console.log(`  ${c.white}${MSG.LAUNCH_AGENTS}:${c.reset}`);
+
+  // User Launch Agents
+  const launchAgentsDir = path.join(HOME, 'Library/LaunchAgents');
+  let idx = 100;
+
+  if (fs.existsSync(launchAgentsDir)) {
+    const agents = fs.readdirSync(launchAgentsDir).filter(f => f.endsWith('.plist'));
+
+    for (const agent of agents) {
+      const name = agent.replace('.plist', '');
+      const loaded = exec(`launchctl list 2>/dev/null | grep "${name}"`);
+
+      const status = loaded ?
+        `${c.green}${CHECK}${c.reset} ${MSG.ENABLED}` :
+        `${c.red}${CROSS}${c.reset} ${MSG.DISABLED}`;
+
+      console.log(`  ${c.cyan}[${idx}]${c.reset} ${status} ${c.dim}${name}${c.reset}`);
+      idx++;
+    }
+  }
+
+  console.log();
+  console.log(`  ${c.dim}Enter number to toggle, 'd' to disable all, or 'n' to go back${c.reset}`);
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  if (choice.toLowerCase() === 'd') {
+    exec(`osascript -e 'tell application "System Events" to delete every login item' 2>/dev/null`);
+    console.log(`  ${c.green}${CHECK}${c.reset} All login items disabled`);
+  }
+
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 6: CLEAN BROWSERS
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function cleanBrowsers() {
+  header();
+  sectionHeader(MSG.BROWSERS_CAT);
+
+  const items = [];
+  let totalBrowser = 0;
+
+  function addBrowserItem(p, name) {
+    const fullPath = p.replace(/^~/, HOME);
+    const size = getSize(p);
+    if (size > 0) {
+      items.push({ path: fullPath, name, size, selected: false });
+      totalBrowser += size;
+    }
+  }
+
+  console.log(`  ${c.white}Chrome:${c.reset}`);
+  addBrowserItem('~/Library/Caches/Google/Chrome', 'Chrome Cache');
+  addBrowserItem('~/Library/Application Support/Google/Chrome/Default/Service Worker', 'Chrome Service Workers');
+  addBrowserItem('~/Library/Application Support/Google/Chrome/Default/GPUCache', 'Chrome GPU Cache');
+
+  console.log(`  ${c.white}Safari:${c.reset}`);
+  addBrowserItem('~/Library/Caches/com.apple.Safari', 'Safari Cache');
+  addBrowserItem('~/Library/Safari/LocalStorage', 'Safari Local Storage');
+
+  console.log(`  ${c.white}Firefox:${c.reset}`);
+  const ffProfile = exec('find ~/Library/Application\\ Support/Firefox/Profiles -maxdepth 1 -name "*.default*" 2>/dev/null | head -1');
+  if (ffProfile) {
+    addBrowserItem(`${ffProfile}/cache2`, 'Firefox Cache');
+  }
+
+  items.forEach((item, i) => {
+    console.log(`  ${c.cyan}[${String(i + 1).padStart(2)}]${c.reset} ${item.name.padEnd(30)} ${c.dim}${String(item.size).padStart(6)} MB${c.reset}`);
+  });
+
+  if (items.length === 0) {
+    console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log();
+  console.log(`  ${ARROW} ${c.white}${MSG.TOTAL}:${c.reset} ${c.green}${formatSize(totalBrowser)}${c.reset}`);
+  console.log();
+
+  console.log(`  ${c.dim}${MSG.SELECT_DELETE} [numbers/a/n]:${c.reset}`);
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    await pressEnter();
+    return;
+  }
+
+  if (choice.toLowerCase() === 'a') {
+    items.forEach(item => item.selected = true);
+  } else {
+    const parts = choice.split(',');
+    parts.forEach(part => {
+      const idx = parseInt(part.trim()) - 1;
+      if (idx >= 0 && idx < items.length) items[idx].selected = true;
+    });
+  }
+
+  let cleaned = 0;
+  console.log();
+
+  for (const item of items) {
+    if (!item.selected) continue;
+    try {
+      fs.rmSync(item.path, { recursive: true, force: true });
+      console.log(`  ${c.green}${CHECK}${c.reset} ${item.name}`);
+      cleaned += item.size;
+    } catch (e) {}
+  }
+
+  console.log();
+  console.log(`  ${c.green}${MSG.FREED}: ${formatSize(cleaned)}${c.reset}`);
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 7: KILL PROCESSES
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function killProcesses() {
+  header();
+  sectionHeader(MSG.PROCESS_MEM);
+
+  console.log(`  ${c.white}${MSG.PROCESS_MEM}:${c.reset}`);
+
+  const procs = [];
+  const totalMemBytes = parseInt(exec("sysctl hw.memsize 2>/dev/null | awk '{print $2}'")) || 8589934592;
+  const totalMemMB = Math.round(totalMemBytes / 1024 / 1024);
+
+  const output = exec('ps aux -m 2>/dev/null | head -15');
+  const lines = output.split('\n').slice(1); // Skip header
+
+  for (const line of lines) {
+    const parts = line.split(/\s+/);
+    if (parts.length < 11) continue;
+
+    const pid = parts[1];
+    const mem = parseFloat(parts[3]) || 0;
+    const name = parts[10];
+
+    // Skip system processes
+    if (['kernel_task', 'WindowServer', 'launchd'].includes(name)) continue;
+
+    const memMB = Math.round(mem * totalMemMB / 100);
+    if (memMB < 100) continue;
+
+    procs.push({ pid, name, memMB });
+
+    console.log(`  ${c.cyan}[${String(procs.length).padStart(2)}]${c.reset} ${name.padEnd(30)} ${c.red}${memMB} MB RAM${c.reset}`);
+
+    if (procs.length >= 10) break;
+  }
+
+  if (procs.length === 0) {
+    console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log();
+  console.log(`  ${c.dim}${MSG.KILL} process [number/n]:${c.reset}`);
+  const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    await pressEnter();
+    return;
+  }
+
+  const idx = parseInt(choice) - 1;
+  if (idx >= 0 && idx < procs.length) {
+    const proc = procs[idx];
+    try {
+      process.kill(parseInt(proc.pid), 'SIGKILL');
+      console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.KILLED}: ${proc.name} (PID: ${proc.pid})`);
+    } catch (e) {
+      console.log(`  ${c.red}${CROSS}${c.reset} ${MSG.FAILED_KILL} ${proc.name}`);
+    }
+  }
+
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 8: STATISTICS
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function showStatistics() {
+  header();
+  sectionHeader(MSG.OPT_STATS);
+
+  if (!fs.existsSync(HISTORY_FILE)) {
+    console.log(`  ${c.dim}${MSG.NO_HISTORY}${c.reset}`);
+    await pressEnter();
+    return;
+  }
+
+  const history = fs.readFileSync(HISTORY_FILE, 'utf8').split('\n').filter(l => l.trim());
+  const currentMonth = new Date().toISOString().slice(0, 7);
+
+  const monthLines = history.filter(l => l.startsWith(currentMonth));
+  const monthCleanups = monthLines.length;
+
+  let monthFreed = 0;
+  let monthScoreSum = 0;
+
+  monthLines.forEach(line => {
+    const freedMatch = line.match(/(\d+)\s*MB/);
+    const scoreMatch = line.match(/Score:\s*(\d+)/);
+    if (freedMatch) monthFreed += parseInt(freedMatch[1]);
+    if (scoreMatch) monthScoreSum += parseInt(scoreMatch[1]);
+  });
+
+  const monthAvg = monthCleanups > 0 ? Math.round(monthScoreSum / monthCleanups) : 0;
+
+  console.log(`  ${c.white}${MSG.THIS_MONTH}:${c.reset}`);
+  console.log(`  ${BULLET} ${MSG.CLEANINGS}: ${monthCleanups}`);
+  console.log(`  ${BULLET} ${MSG.TOTAL} ${MSG.FREED}: ${formatSize(monthFreed)}`);
+  console.log(`  ${BULLET} ${MSG.AVG_SCORE}: ${monthAvg}/100`);
+  console.log();
+
+  console.log(`  ${c.white}${MSG.HISTORY}:${c.reset}`);
+  history.slice(-10).forEach(line => {
+    console.log(`  ${c.dim}${line}${c.reset}`);
+  });
+
+  await pressEnter();
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// OPTION 9: SETTINGS
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function showSettings() {
+  while (true) {
+    header();
+    sectionHeader(MSG.OPT_SETTINGS);
+
+    const currentLang = LANG_CODE === 'en' ? 'EN' : 'PT';
+
+    console.log(`  ${c.cyan}[1]${c.reset} ${MSG.EXCLUSIONS}`);
+    console.log(`  ${c.cyan}[2]${c.reset} ${MSG.CUSTOM_PATHS}`);
+    console.log(`  ${c.cyan}[3]${c.reset} ${MSG.CHANGE_LANG} (current: ${currentLang})`);
+    console.log(`  ${c.cyan}[4]${c.reset} ${MSG.RESET_DEFAULTS}`);
+    console.log();
+    console.log(`  ${c.cyan}[0]${c.reset} ${MSG.BACK}`);
+    console.log();
+
+    const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+    switch (choice) {
+      case '1':
+        // Manage exclusions
+        header();
+        sectionHeader(MSG.EXCLUSIONS);
+
+        console.log(`  ${c.white}${MSG.CURRENT_EXCLUSIONS}:${c.reset}`);
+        if (fs.existsSync(EXCLUSIONS_FILE)) {
+          const exclusions = fs.readFileSync(EXCLUSIONS_FILE, 'utf8').split('\n').filter(l => l.trim());
+          exclusions.forEach((ex, i) => console.log(`  ${i + 1}. ${ex}`));
+        } else {
+          console.log(`  ${c.dim}None${c.reset}`);
+        }
+        console.log();
+        console.log(`  ${c.dim}${MSG.ENTER_PATH}:${c.reset}`);
+
+        const newExclusion = await prompt(`  ${c.white}${MSG.PATH}:${c.reset} `);
+
+        if (newExclusion === 'c') {
+          if (fs.existsSync(EXCLUSIONS_FILE)) fs.unlinkSync(EXCLUSIONS_FILE);
+          console.log(`  ${c.green}${CHECK}${c.reset} Exclusions ${MSG.CLEARED}`);
+        } else if (newExclusion !== 'n' && newExclusion) {
+          fs.appendFileSync(EXCLUSIONS_FILE, newExclusion + '\n');
+          console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.ADDED}: ${newExclusion}`);
+        }
+        await pressEnter();
+        break;
+
+      case '2':
+        // Custom paths
+        header();
+        sectionHeader(MSG.CUSTOM_PATHS);
+
+        console.log(`  ${c.white}${MSG.CURRENT_PATHS}:${c.reset}`);
+        if (fs.existsSync(CUSTOM_PATHS_FILE)) {
+          const paths = fs.readFileSync(CUSTOM_PATHS_FILE, 'utf8').split('\n').filter(l => l.trim() && !l.startsWith('#'));
+          paths.forEach((p, i) => console.log(`  ${i + 1}. ${p}`));
+        } else {
+          console.log(`  ${c.dim}None${c.reset}`);
+        }
+        console.log();
+        console.log(`  ${c.dim}${MSG.ENTER_PATH}:${c.reset}`);
+
+        const newPath = await prompt(`  ${c.white}${MSG.PATH}:${c.reset} `);
+
+        if (newPath === 'c') {
+          if (fs.existsSync(CUSTOM_PATHS_FILE)) fs.unlinkSync(CUSTOM_PATHS_FILE);
+          console.log(`  ${c.green}${CHECK}${c.reset} Custom paths ${MSG.CLEARED}`);
+        } else if (newPath !== 'n' && newPath) {
+          fs.appendFileSync(CUSTOM_PATHS_FILE, newPath + '\n');
+          console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.ADDED}: ${newPath}`);
+        }
+        await pressEnter();
+        break;
+
+      case '3':
+        // Change language
+        const newLang = LANG_CODE === 'pt' ? 'en' : 'pt';
+        fs.writeFileSync(LANGUAGE_FILE, newLang);
+        console.log(`  ${c.green}${CHECK}${c.reset} ${newLang === 'en' ? MSG.LANG_CHANGED_EN : MSG.LANG_CHANGED_PT}`);
+        await pressEnter();
+        // Restart to apply language change
+        const { spawn } = require('child_process');
+        spawn(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+        process.exit(0);
+        break;
+
+      case '4':
+        // Reset defaults
+        [EXCLUSIONS_FILE, CUSTOM_PATHS_FILE, LANGUAGE_FILE].forEach(f => {
+          if (fs.existsSync(f)) fs.unlinkSync(f);
+        });
+        console.log(`  ${c.green}${CHECK}${c.reset} ${MSG.SETTINGS_RESET}`);
+        await pressEnter();
+        // Restart to apply changes
+        const { spawn: spawn2 } = require('child_process');
+        spawn2(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+        process.exit(0);
+        break;
+
+      case '0':
+        return;
+
+      default:
+        break;
+    }
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// MAIN MENU
+// ══════════════════════════════════════════════════════════════════════════════
+
+async function mainMenu() {
+  while (true) {
+    header();
+
+    console.log(`  ${c.cyan}[1]${c.reset} 🧹 ${MSG.OPT_QUICK}`);
+    console.log(`  ${c.cyan}[2]${c.reset} 📦 ${MSG.OPT_LARGE}`);
+    console.log(`  ${c.cyan}[3]${c.reset} 🔄 ${MSG.OPT_DUPLICATES}`);
+    console.log(`  ${c.cyan}[4]${c.reset} 🗑️  ${MSG.OPT_APPS}`);
+    console.log(`  ${c.cyan}[5]${c.reset} 🚀 ${MSG.OPT_STARTUP}`);
+    console.log(`  ${c.cyan}[6]${c.reset} 🌐 ${MSG.OPT_BROWSERS}`);
+    console.log(`  ${c.cyan}[7]${c.reset} 💀 ${MSG.OPT_PROCESSES}`);
+    console.log(`  ${c.cyan}[8]${c.reset} 📊 ${MSG.OPT_STATS}`);
+    console.log(`  ${c.cyan}[9]${c.reset} ⚙️  ${MSG.OPT_SETTINGS}`);
+    console.log();
+    console.log(`  ${c.cyan}[0]${c.reset} ${MSG.OPT_EXIT}`);
+    console.log();
+
+    const choice = await prompt(`  ${c.white}${MSG.CHOOSE}:${c.reset} `);
+
+    switch (choice) {
+      case '1': await quickClean(); break;
+      case '2': await findLargeFiles(); break;
+      case '3': await findDuplicates(); break;
+      case '4': await uninstallApps(); break;
+      case '5': await manageStartup(); break;
+      case '6': await cleanBrowsers(); break;
+      case '7': await killProcesses(); break;
+      case '8': await showStatistics(); break;
+      case '9': await showSettings(); break;
+      case '0':
+        clearScreen();
+        console.log();
+        console.log(`${c.dim}por Salvador Reis ${BULLET} github.com/salvadorreis${c.reset}`);
+        console.log();
+        process.exit(0);
+        break;
+      default:
+        console.log(`  ${c.red}${MSG.INVALID}${c.reset}`);
+        await new Promise(r => setTimeout(r, 1000));
+    }
+  }
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ══════════════════════════════════════════════════════════════════════════════
+
+// Check if macOS
+if (os.platform() !== 'darwin') {
+  console.log('This program only works on macOS');
+  process.exit(1);
+}
+
+// Command line arguments
+const args = process.argv.slice(2);
+
+if (args.includes('--preview') || args.includes('--dry-run')) {
+  console.log('Preview mode - nothing will be deleted');
+  process.exit(0);
+}
+
+if (args.includes('--quick') || args.includes('-q')) {
+  (async () => {
+    getSystemStats();
+    await quickClean();
+  })();
+} else if (args.includes('--version') || args.includes('-v')) {
+  console.log(`Aris Mac Cleaner v${VERSION}`);
+  process.exit(0);
+} else if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+Aris Mac Cleaner v${VERSION}
+
+Usage:
+  aris-mac-cleaner          Start interactive menu
+  aris-mac-cleaner -q       Quick clean without menu
+  aris-mac-cleaner -v       Show version
+  aris-mac-cleaner -h       Show this help
+
+Config directory: ~/.aris-mac-cleaner/
+`);
+  process.exit(0);
+} else {
+  mainMenu();
+}