aris-mac-cleaner 2.0.0 → 3.5.0

package/bin/cli.js

@@ -1,34 +1,456 @@
 #!/usr/bin/env node
 
-const { execSync, spawnSync } = require('child_process');
+// ============================================================================
+//                         ARIS MAC CLEANER v3.5 PREMIUM
+//                            por Salvador Reis
+// ============================================================================
+
+const { execSync, spawnSync, spawn } = require('child_process');
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
+const readline = require('readline');
+const crypto = require('crypto');
+const https = require('https');
 
-// Cores
-const colors = {
-  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'
-};
+// Premium dependencies (with fallbacks)
+let chalk, gradient, ora, cliProgress, asciichart, notifier, boxen, figures;
 
-const c = colors;
+try {
+  chalk = require('chalk');
+} catch (e) {
+  chalk = {
+    cyan: s => `\x1b[36m${s}\x1b[0m`,
+    green: s => `\x1b[32m${s}\x1b[0m`,
+    red: s => `\x1b[31m${s}\x1b[0m`,
+    yellow: s => `\x1b[33m${s}\x1b[0m`,
+    white: s => `\x1b[37m${s}\x1b[0m`,
+    gray: s => `\x1b[90m${s}\x1b[0m`,
+    dim: s => `\x1b[2m${s}\x1b[0m`,
+    bold: s => `\x1b[1m${s}\x1b[0m`,
+    magenta: s => `\x1b[35m${s}\x1b[0m`,
+    blue: s => `\x1b[34m${s}\x1b[0m`,
+    bgCyan: { black: s => `\x1b[46m\x1b[30m${s}\x1b[0m` },
+    bgGreen: { black: s => `\x1b[42m\x1b[30m${s}\x1b[0m` },
+    bgRed: { white: s => `\x1b[41m\x1b[37m${s}\x1b[0m` },
+    bgYellow: { black: s => `\x1b[43m\x1b[30m${s}\x1b[0m` }
+  };
+}
 
-// Verificar se é macOS
-if (os.platform() !== 'darwin') {
-  console.log(`${c.red}Este programa só funciona em macOS${c.reset}`);
-  process.exit(1);
+try {
+  gradient = require('gradient-string');
+} catch (e) {
+  gradient = {
+    pastel: { multiline: s => s },
+    cristal: { multiline: s => s },
+    rainbow: { multiline: s => s },
+    vice: { multiline: s => s },
+    mind: { multiline: s => s }
+  };
+}
+
+try {
+  ora = require('ora');
+} catch (e) {
+  ora = (text) => ({
+    start: () => ({ succeed: () => {}, fail: () => {}, stop: () => {}, text: '' }),
+    succeed: () => {},
+    fail: () => {},
+    stop: () => {}
+  });
+}
+
+try {
+  cliProgress = require('cli-progress');
+} catch (e) {
+  cliProgress = {
+    SingleBar: class {
+      constructor() {}
+      start() {}
+      update() {}
+      stop() {}
+      increment() {}
+    },
+    Presets: { shades_classic: {} }
+  };
+}
+
+try {
+  asciichart = require('asciichart');
+} catch (e) {
+  asciichart = { plot: (data) => data.join(', ') };
 }
 
+try {
+  notifier = require('node-notifier');
+} catch (e) {
+  notifier = { notify: () => {} };
+}
+
+try {
+  boxen = require('boxen');
+} catch (e) {
+  boxen = (text) => text;
+}
+
+try {
+  figures = require('figures');
+} catch (e) {
+  figures = {
+    tick: '\u2713',
+    cross: '\u2717',
+    bullet: '\u2022',
+    arrowRight: '\u2192',
+    warning: '\u26A0',
+    info: '\u2139',
+    star: '\u2605',
+    heart: '\u2665',
+    pointer: '\u25B6',
+    line: '\u2500',
+    radioOn: '\u25C9',
+    radioOff: '\u25EF',
+    checkboxOn: '\u2612',
+    checkboxOff: '\u2610'
+  };
+}
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+const VERSION = '3.5.0';
+const PACKAGE_NAME = 'aris-mac-cleaner';
 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');
+const BACKUP_DIR = path.join(CONFIG_DIR, 'backups');
+const REPORTS_DIR = path.join(CONFIG_DIR, 'reports');
+const SCHEDULE_FILE = path.join(CONFIG_DIR, 'schedule.plist');
+const BENCHMARK_FILE = path.join(CONFIG_DIR, 'benchmark.log');
+const USAGE_FILE = path.join(CONFIG_DIR, 'usage.json');
+
+// Ensure directories exist
+[CONFIG_DIR, BACKUP_DIR, REPORTS_DIR].forEach(dir => {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+});
+
+// ============================================================================
+// GLOBAL STATE
+// ============================================================================
+
+let DRY_RUN = false;
+let SECURE_DELETE = false;
+let systemStats = {};
+let lastCleanupResults = null;
+
+// ============================================================================
+// MULTI-LANGUAGE
+// ============================================================================
+
+let LANG_CODE = 'pt';
+if (fs.existsSync(LANGUAGE_FILE)) {
+  LANG_CODE = fs.readFileSync(LANGUAGE_FILE, 'utf8').trim();
+}
+
+const MSG = LANG_CODE === 'pt' ? {
+  WELCOME: 'Bem-vindo ao Aris Mac Cleaner',
+  MENU_TITLE: 'MENU PRINCIPAL',
+  OPT_QUICK: 'Limpeza Rapida',
+  OPT_LARGE: 'Ficheiros Grandes',
+  OPT_DUPLICATES: 'Duplicados',
+  OPT_APPS: 'Desinstalar Apps',
+  OPT_STARTUP: 'Apps de Arranque',
+  OPT_BROWSERS: 'Limpar Browsers',
+  OPT_PROCESSES: 'Processos Pesados',
+  OPT_STATS: 'Estatisticas',
+  OPT_SETTINGS: 'Configuracoes',
+  OPT_DISK: 'Analisador Disco',
+  OPT_PRIVACY: 'Limpeza Privacidade',
+  OPT_MEMORY: 'Otimizar Memoria',
+  OPT_BENCHMARK: 'Benchmark',
+  OPT_SCHEDULER: 'Agendar Limpeza',
+  OPT_EXPORT: 'Exportar Relatorio',
+  OPT_EXIT: 'Sair',
+  CHOOSE: 'Escolha',
+  INVALID: 'Opcao invalida',
+  PRESS_ENTER: 'Pressiona ENTER para continuar',
+  SCANNING: 'A analisar...',
+  FOUND: 'Encontrado',
+  TOTAL: 'Total',
+  DELETE: 'Apagar',
+  KEEP: 'Manter',
+  CANCEL: 'Cancelar',
+  CONFIRM: 'Confirmar',
+  FREED: 'Libertado',
+  AVAILABLE: 'Disponivel',
+  HEALTH_SCORE: 'Health Score',
+  EXCELLENT: 'Excelente',
+  GOOD: 'Bom',
+  ATTENTION: 'Atencao',
+  CRITICAL: 'Critico',
+  DIAGNOSE: 'DIAGNOSTICO 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: 'RELATORIO FINAL',
+  READY: 'Pronto para trabalhar!',
+  RESTART_REC: 'Recomendacao: Reinicia o Mac para limpar memoria',
+  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: 'Aplicacoes',
+  PROCESS_MEM: 'Por Memoria',
+  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 mes',
+  CLEANINGS: 'Limpezas',
+  AVG_SCORE: 'Score medio',
+  HISTORY: 'Historico',
+  EXCLUSIONS: 'Gerir Exclusoes',
+  CUSTOM_PATHS: 'Caminhos Personalizados',
+  CHANGE_LANG: 'Mudar Idioma',
+  RESET_DEFAULTS: 'Repor Predefinicoes',
+  PREVIEW_MODE: 'Modo Preview (nao apaga nada)',
+  LARGE_FILES: 'FICHEIROS GRANDES',
+  DUPLICATES: 'FICHEIROS DUPLICADOS',
+  UNINSTALL: 'DESINSTALAR APLICACOES',
+  APP_SIZE: 'app',
+  DATA_SIZE: 'dados',
+  CURRENT_EXCLUSIONS: 'Exclusoes 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 Portugues',
+  SETTINGS_RESET: 'Configuracoes repostas',
+  REMOVED: 'Removido',
+  NEED_SUDO: 'Precisa sudo para remover app. Executa:',
+  DELETING: 'A apagar',
+  KILLED: 'Morto',
+  FAILED_KILL: 'Falhou ao matar',
+  NO_HISTORY: 'Sem historico. Faz algumas limpezas primeiro!',
+  FEATURE_PROGRESS: 'Funcionalidade em progresso...',
+  GROUP: 'Grupo',
+  EACH: 'cada',
+  IN_DUPLICATES: 'em duplicados',
+  HASHING: 'A calcular hashes...',
+  DRY_RUN_MODE: 'MODO DRY-RUN (nada sera apagado)',
+  SECURE_DELETE_MODE: 'MODO SEGURO (overwrite antes de apagar)',
+  BACKUP_CREATED: 'Backup criado',
+  SCHEDULE_CREATED: 'Agendamento criado',
+  SCHEDULE_REMOVED: 'Agendamento removido',
+  REPORT_EXPORTED: 'Relatorio exportado',
+  UPDATE_AVAILABLE: 'Atualizacao disponivel',
+  UP_TO_DATE: 'Ja tens a versao mais recente',
+  MEMORY_FREED: 'Memoria libertada',
+  PRIVACY_CLEANED: 'Privacidade limpa',
+  BENCHMARK_COMPLETE: 'Benchmark completo',
+  RECOMMENDATIONS: 'RECOMENDACOES',
+  DISK_ANALYSIS: 'ANALISE DE DISCO',
+  SCHEDULED_DAILY: 'Agendado diariamente',
+  SCHEDULED_WEEKLY: 'Agendado semanalmente',
+  CLEANUP_COMPLETE: 'Limpeza completa!'
+} : {
+  WELCOME: 'Welcome to Aris Mac Cleaner',
+  MENU_TITLE: 'MAIN MENU',
+  OPT_QUICK: 'Quick Clean',
+  OPT_LARGE: 'Large Files',
+  OPT_DUPLICATES: 'Duplicates',
+  OPT_APPS: 'Uninstall Apps',
+  OPT_STARTUP: 'Startup Apps',
+  OPT_BROWSERS: 'Clean Browsers',
+  OPT_PROCESSES: 'Heavy Processes',
+  OPT_STATS: 'Statistics',
+  OPT_SETTINGS: 'Settings',
+  OPT_DISK: 'Disk Analyzer',
+  OPT_PRIVACY: 'Privacy Sweep',
+  OPT_MEMORY: 'Memory Optimizer',
+  OPT_BENCHMARK: 'Benchmark',
+  OPT_SCHEDULER: 'Schedule Cleanup',
+  OPT_EXPORT: 'Export Report',
+  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 Portugues',
+  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...',
+  DRY_RUN_MODE: 'DRY-RUN MODE (nothing will be deleted)',
+  SECURE_DELETE_MODE: 'SECURE MODE (overwrite before delete)',
+  BACKUP_CREATED: 'Backup created',
+  SCHEDULE_CREATED: 'Schedule created',
+  SCHEDULE_REMOVED: 'Schedule removed',
+  REPORT_EXPORTED: 'Report exported',
+  UPDATE_AVAILABLE: 'Update available',
+  UP_TO_DATE: 'You have the latest version',
+  MEMORY_FREED: 'Memory freed',
+  PRIVACY_CLEANED: 'Privacy cleaned',
+  BENCHMARK_COMPLETE: 'Benchmark complete',
+  RECOMMENDATIONS: 'RECOMMENDATIONS',
+  DISK_ANALYSIS: 'DISK ANALYSIS',
+  SCHEDULED_DAILY: 'Scheduled daily',
+  SCHEDULED_WEEKLY: 'Scheduled weekly',
+  CLEANUP_COMPLETE: 'Cleanup complete!'
+};
+
+// ============================================================================
+// ANIMATED ASCII LOGO
+// ============================================================================
+
+const ASCII_LOGO = `
+    _    ____  ___ ____
+   / \\  |  _ \\|_ _/ ___|
+  / _ \\ | |_) || |\\___ \\
+ / ___ \\|  _ < | | ___) |
+/_/   \\_\\_| \\_\\___|____/
+
+ MAC CLEANER v${VERSION} PREMIUM
+`;
+
+const ASCII_LOGO_FRAMES = [
+  `
+    _
+   / \\
+  / _ \\
+ / ___ \\
+/_/   \\_\\
+`,
+  `
+    _    ____
+   / \\  |  _ \\
+  / _ \\ | |_) |
+ / ___ \\|  _ <
+/_/   \\_\\_| \\_\\
+`,
+  `
+    _    ____  ___ ____
+   / \\  |  _ \\|_ _/ ___|
+  / _ \\ | |_) || |\\___ \\
+ / ___ \\|  _ < | | ___) |
+/_/   \\_\\_| \\_\\___|____/
+`,
+  ASCII_LOGO
+];
+
+async function animateLogo() {
+  const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+  for (const frame of ASCII_LOGO_FRAMES) {
+    process.stdout.write('\x1b[2J\x1b[H');
+    console.log(gradient.cristal.multiline(frame));
+    await sleep(150);
+  }
+
+  // Final sparkle effect
+  process.stdout.write('\x1b[2J\x1b[H');
+  console.log(gradient.pastel.multiline(ASCII_LOGO));
+  await sleep(300);
+}
+
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
 
-// Função para executar comandos
 function exec(cmd) {
   try {
     return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
@@ -37,211 +459,2182 @@ 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 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(`  ${chalk.dim(MSG.PRESS_ENTER + '...')} `);
+}
+
+// ============================================================================
+// PREMIUM HEADER WITH GRADIENT
+// ============================================================================
+
+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' });
+
+  const titleBox = `
+${chalk.cyan('+')}${chalk.cyan('-'.repeat(68))}${chalk.cyan('+')}
+${chalk.cyan('|')}${chalk.white('                    ARIS MAC CLEANER v' + VERSION + ' PREMIUM                 ')}${chalk.cyan('|')}
+${chalk.cyan('|')}${chalk.gray('                  ' + date + ' ' + figures.bullet + ' ' + time + '                   ')}${chalk.cyan('|')}
+${chalk.cyan('+')}${chalk.cyan('-'.repeat(68))}${chalk.cyan('+')}
+`;
+
+  console.log(gradient.pastel.multiline(titleBox));
+
+  // Show mode indicators
+  if (DRY_RUN) {
+    console.log(chalk.bgYellow.black(` ${figures.warning} ${MSG.DRY_RUN_MODE} `));
+    console.log();
+  }
+  if (SECURE_DELETE) {
+    console.log(chalk.bgRed.white(` ${figures.warning} ${MSG.SECURE_DELETE_MODE} `));
+    console.log();
+  }
+}
+
+function sectionHeader(title) {
+  console.log(chalk.white('+' + '-'.repeat(65) + '+'));
+  console.log(chalk.white('|') + '  ' + chalk.cyan(figures.pointer + ' ' + title));
+  console.log(chalk.white('+' + '-'.repeat(65) + '+'));
+  console.log();
+}
+
+// ============================================================================
+// AUTO-UPDATE CHECKER
+// ============================================================================
+
+async function checkForUpdates() {
+  return new Promise((resolve) => {
+    const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const latestVersion = json.version;
+          if (latestVersion && latestVersion !== VERSION) {
+            resolve({ hasUpdate: true, version: latestVersion });
+          } else {
+            resolve({ hasUpdate: false });
+          }
+        } catch (e) {
+          resolve({ hasUpdate: false });
+        }
+      });
+    });
+
+    req.on('error', () => resolve({ hasUpdate: false }));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ hasUpdate: false });
+    });
+  });
+}
+
+async function showUpdateNotification() {
+  const update = await checkForUpdates();
+  if (update.hasUpdate) {
+    console.log();
+    console.log(chalk.bgGreen.black(` ${figures.star} ${MSG.UPDATE_AVAILABLE}: v${update.version} `));
+    console.log(chalk.dim(`  npm update -g ${PACKAGE_NAME}`));
+    console.log();
+  }
+}
+
+// ============================================================================
+// BACKUP SYSTEM
+// ============================================================================
+
+function createBackup(items) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const backupFile = path.join(BACKUP_DIR, `backup-${timestamp}.json`);
+
+  const backupData = {
+    timestamp: new Date().toISOString(),
+    version: VERSION,
+    items: items.map(item => ({
+      path: item.path,
+      name: item.name,
+      size: item.size,
+      category: item.category
+    }))
+  };
+
+  fs.writeFileSync(backupFile, JSON.stringify(backupData, null, 2));
+  return backupFile;
+}
+
+function listBackups() {
+  if (!fs.existsSync(BACKUP_DIR)) return [];
+  return fs.readdirSync(BACKUP_DIR)
+    .filter(f => f.endsWith('.json'))
+    .sort()
+    .reverse()
+    .slice(0, 10);
+}
+
+// ============================================================================
+// SECURE DELETE
+// ============================================================================
+
+function secureDelete(filePath) {
+  if (!fs.existsSync(filePath)) return;
+
+  const stats = fs.statSync(filePath);
+
+  if (stats.isDirectory()) {
+    // For directories, just use rm -rf (secure delete of dirs is complex)
+    fs.rmSync(filePath, { recursive: true, force: true });
+    return;
+  }
+
+  // Overwrite file content 3 times before deletion
+  const size = stats.size;
+  const fd = fs.openSync(filePath, 'w');
+
+  // Pass 1: zeros
+  const zeros = Buffer.alloc(Math.min(size, 1024 * 1024), 0);
+  let written = 0;
+  while (written < size) {
+    fs.writeSync(fd, zeros, 0, Math.min(zeros.length, size - written));
+    written += zeros.length;
+  }
+
+  // Pass 2: ones
+  fs.lseekSync ? fs.lseekSync(fd, 0, 0) : null;
+  const ones = Buffer.alloc(Math.min(size, 1024 * 1024), 0xFF);
+  written = 0;
+  while (written < size) {
+    fs.writeSync(fd, ones, 0, Math.min(ones.length, size - written));
+    written += ones.length;
+  }
+
+  // Pass 3: random
+  const random = crypto.randomBytes(Math.min(size, 1024 * 1024));
+  written = 0;
+  while (written < size) {
+    fs.writeSync(fd, random, 0, Math.min(random.length, size - written));
+    written += random.length;
+  }
+
+  fs.closeSync(fd);
+  fs.unlinkSync(filePath);
+}
+
+function deleteItem(itemPath) {
+  if (DRY_RUN) {
+    console.log(chalk.yellow(`  ${figures.info} [DRY-RUN] Would delete: ${itemPath}`));
+    return true;
+  }
+
+  try {
+    if (SECURE_DELETE) {
+      secureDelete(itemPath);
+    } else {
+      fs.rmSync(itemPath, { recursive: true, force: true });
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// ============================================================================
+// PROGRESS BAR
+// ============================================================================
+
+function createProgressBar(total, format) {
+  return new cliProgress.SingleBar({
+    format: format || '  {bar} | {percentage}% | {value}/{total}',
+    barCompleteChar: '\u2588',
+    barIncompleteChar: '\u2591',
+    hideCursor: true
+  }, cliProgress.Presets.shades_classic);
+}
+
+// ============================================================================
+// SYSTEM DIAGNOSTICS
+// ============================================================================
+
+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 = chalk.green(`${figures.tick} ${MSG.EXCELLENT}`);
+  } else if (systemStats.diskPercent < 80) {
+    systemStats.diskStatus = chalk.yellow(`${figures.warning} ${MSG.ATTENTION}`);
+  } else {
+    systemStats.diskStatus = chalk.red(`${figures.cross} ${MSG.CRITICAL}`);
+  }
+
+  // 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 = chalk.green(`${figures.tick} OK`);
+  } else if (systemStats.ramUsedPercent < 90) {
+    systemStats.ramStatus = chalk.yellow(`${figures.warning} ${MSG.ATTENTION}`);
+  } else {
+    systemStats.ramStatus = chalk.red(`${figures.cross} ${MSG.CRITICAL}`);
+  }
+
+  // Swap
+  const swapStr = exec("sysctl vm.swapusage 2>/dev/null | awk '{print $7}'");
+  systemStats.swapUsed = parseInt(swapStr) || 0;
+
+  if (systemStats.swapUsed < 2000) {
+    systemStats.swapStatus = chalk.green(`${figures.tick} OK`);
+  } else if (systemStats.swapUsed < 8000) {
+    systemStats.swapStatus = chalk.yellow(`${figures.warning} High`);
+  } else {
+    systemStats.swapStatus = chalk.red(`${figures.cross} ${MSG.CRITICAL}`);
+  }
+
+  // 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 = chalk.green(`${figures.tick} OK`);
+  } else if (systemStats.cpuUsed < 80) {
+    systemStats.cpuStatus = chalk.yellow(`${figures.warning} ${MSG.ATTENTION}`);
+  } else {
+    systemStats.cpuStatus = chalk.red(`${figures.cross} ${MSG.CRITICAL}`);
+  }
+}
+
+function showDiagnostics() {
+  sectionHeader(MSG.DIAGNOSE);
+  console.log(`  ${figures.bullet} ${chalk.white(MSG.DISK)}      ${systemStats.diskFree}GB ${MSG.FREE_OF} ${systemStats.diskTotal}GB    ${systemStats.diskStatus}`);
+  console.log(`  ${figures.bullet} ${chalk.white(MSG.RAM)}        ${systemStats.ramUsedPercent}% ${MSG.IN_USE}                  ${systemStats.ramStatus}`);
+  console.log(`  ${figures.bullet} ${chalk.white(MSG.SWAP)}       ${systemStats.swapUsed}MB ${MSG.IN_USE}               ${systemStats.swapStatus}`);
+  console.log(`  ${figures.bullet} ${chalk.white(MSG.CPU)}        ${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 = chalk.green;
+  let text = MSG.EXCELLENT;
+  if (score < 60) { color = chalk.red; text = MSG.ATTENTION; }
+  else if (score < 80) { color = chalk.yellow; text = MSG.GOOD; }
+
+  return { score, color, text };
+}
+
+// ============================================================================
+// SOUND NOTIFICATION
+// ============================================================================
+
+function playNotificationSound() {
+  // Use macOS native sound
+  exec('afplay /System/Library/Sounds/Glass.aiff &');
+
+  // Also show system notification
+  notifier.notify({
+    title: 'Aris Mac Cleaner',
+    message: MSG.CLEANUP_COMPLETE,
+    sound: true,
+    icon: path.join(__dirname, 'icon.png')
+  });
+}
+
+// ============================================================================
+// SMART RECOMMENDATIONS
+// ============================================================================
+
+function getSmartRecommendations() {
+  const recommendations = [];
+
+  // Check disk usage
+  if (systemStats.diskPercent > 80) {
+    recommendations.push({
+      priority: 'high',
+      icon: figures.warning,
+      text: LANG_CODE === 'pt'
+        ? 'Disco quase cheio! Considera apagar ficheiros grandes ou desinstalar apps.'
+        : 'Disk almost full! Consider deleting large files or uninstalling apps.'
+    });
+  }
+
+  // Check RAM
+  if (systemStats.ramUsedPercent > 85) {
+    recommendations.push({
+      priority: 'high',
+      icon: figures.warning,
+      text: LANG_CODE === 'pt'
+        ? 'Memoria RAM muito usada. Usa o otimizador de memoria ou mata processos pesados.'
+        : 'RAM heavily used. Use memory optimizer or kill heavy processes.'
+    });
+  }
+
+  // Check swap
+  if (systemStats.swapUsed > 5000) {
+    recommendations.push({
+      priority: 'medium',
+      icon: figures.info,
+      text: LANG_CODE === 'pt'
+        ? 'Swap elevado. Considera reiniciar o Mac para limpar.'
+        : 'High swap usage. Consider restarting Mac to clear.'
+    });
+  }
+
+  // Check history for patterns
+  if (fs.existsSync(HISTORY_FILE)) {
+    const history = fs.readFileSync(HISTORY_FILE, 'utf8').split('\n').filter(l => l.trim());
+    const lastWeek = history.filter(l => {
+      const date = new Date(l.split(' | ')[0]);
+      return (Date.now() - date.getTime()) < 7 * 24 * 60 * 60 * 1000;
+    });
+
+    if (lastWeek.length === 0) {
+      recommendations.push({
+        priority: 'low',
+        icon: figures.star,
+        text: LANG_CODE === 'pt'
+          ? 'Nao fizeste limpeza esta semana. Considera fazer uma limpeza rapida.'
+          : 'No cleanup this week. Consider running a quick clean.'
+      });
+    }
+  }
+
+  // Check for large caches
+  const chromeCache = getSize('~/Library/Caches/Google');
+  if (chromeCache > 500) {
+    recommendations.push({
+      priority: 'medium',
+      icon: figures.bullet,
+      text: LANG_CODE === 'pt'
+        ? `Cache do Chrome com ${formatSize(chromeCache)}. Limpa os browsers.`
+        : `Chrome cache at ${formatSize(chromeCache)}. Clean browsers.`
+    });
+  }
+
+  // Check Xcode
+  const xcodeData = getSize('~/Library/Developer/Xcode/DerivedData');
+  if (xcodeData > 1000) {
+    recommendations.push({
+      priority: 'medium',
+      icon: figures.bullet,
+      text: LANG_CODE === 'pt'
+        ? `Xcode DerivedData com ${formatSize(xcodeData)}. Pode ser limpo.`
+        : `Xcode DerivedData at ${formatSize(xcodeData)}. Can be cleaned.`
+    });
+  }
+
+  return recommendations;
+}
+
+function showRecommendations() {
+  const recs = getSmartRecommendations();
+
+  if (recs.length === 0) return;
+
+  sectionHeader(MSG.RECOMMENDATIONS);
+
+  recs.forEach(rec => {
+    const color = rec.priority === 'high' ? chalk.red :
+                  rec.priority === 'medium' ? chalk.yellow : chalk.cyan;
+    console.log(`  ${color(rec.icon)} ${rec.text}`);
+  });
+  console.log();
+}
+
+// ============================================================================
+// FINAL REPORT
+// ============================================================================
+
+function showFinalReport(freed) {
+  const diskFreeAfter = exec("df -h / | tail -1").split(/\s+/)[3];
+  const health = calculateHealthScore();
+
+  const reportBox = `
+${chalk.cyan('+')}${chalk.cyan('='.repeat(68))}${chalk.cyan('+')}
+${chalk.cyan('|')}${chalk.white('                         ' + MSG.FINAL_REPORT + '                          ')}${chalk.cyan('|')}
+${chalk.cyan('+')}${chalk.cyan('='.repeat(68))}${chalk.cyan('+')}
+${chalk.cyan('|')}                                                                    ${chalk.cyan('|')}
+${chalk.cyan('|')}   ${chalk.white(MSG.DISK)}                                                           ${chalk.cyan('|')}
+${chalk.cyan('|')}   ${figures.arrowRight} ${MSG.AVAILABLE}: ${chalk.green(diskFreeAfter)}                                         ${chalk.cyan('|')}
+${freed > 0 ? `${chalk.cyan('|')}   ${figures.arrowRight} ${MSG.FREED}:  ${chalk.green('+' + formatSize(freed))}                                       ${chalk.cyan('|')}` : ''}
+${chalk.cyan('|')}                                                                    ${chalk.cyan('|')}
+${chalk.cyan('|')}   ${chalk.white(MSG.HEALTH_SCORE)}                                                    ${chalk.cyan('|')}
+${chalk.cyan('|')}   ${figures.arrowRight} ${health.color(health.score + '/100 - ' + health.text)}                                         ${chalk.cyan('|')}
+${chalk.cyan('|')}                                                                    ${chalk.cyan('|')}
+${chalk.cyan('+')}${chalk.cyan('='.repeat(68))}${chalk.cyan('+')}
+`;
+
+  console.log(gradient.pastel.multiline(reportBox));
+
+  if (systemStats.swapUsed > 5000 || systemStats.ramUsedPercent > 85) {
+    console.log(chalk.yellow(`${figures.warning} ${MSG.RESTART_REC}`));
+    console.log();
+  }
+
+  console.log(chalk.green(`${figures.tick} ${MSG.READY}`));
+
+  // Store results for export
+  lastCleanupResults = {
+    timestamp: new Date().toISOString(),
+    freed: freed,
+    diskFree: diskFreeAfter,
+    healthScore: health.score,
+    healthText: health.text
+  };
+
+  logCleanup(freed, health.score);
+
+  // Play notification sound
+  playNotificationSound();
+}
+
+// ============================================================================
+// DISK ANALYZER
+// ============================================================================
+
+async function diskAnalyzer() {
+  header();
+  sectionHeader(MSG.DISK_ANALYSIS);
+
+  const spinner = ora(MSG.SCANNING).start();
+
+  // Analyze key directories
+  const dirs = [
+    { path: HOME, name: 'Home' },
+    { path: path.join(HOME, 'Library'), name: 'Library' },
+    { path: path.join(HOME, 'Documents'), name: 'Documents' },
+    { path: path.join(HOME, 'Downloads'), name: 'Downloads' },
+    { path: path.join(HOME, 'Desktop'), name: 'Desktop' },
+    { path: path.join(HOME, 'Movies'), name: 'Movies' },
+    { path: path.join(HOME, 'Music'), name: 'Music' },
+    { path: path.join(HOME, 'Pictures'), name: 'Pictures' },
+    { path: '/Applications', name: 'Applications' }
+  ];
+
+  const sizes = [];
+
+  for (const dir of dirs) {
+    if (fs.existsSync(dir.path)) {
+      dir.size = getSize(dir.path);
+      sizes.push(dir);
+    }
+  }
+
+  // Sort by size
+  sizes.sort((a, b) => b.size - a.size);
+
+  spinner.stop();
+
+  // Calculate max for bar scaling
+  const maxSize = Math.max(...sizes.map(s => s.size));
+  const barWidth = 40;
+
+  console.log(chalk.white('  Directory Usage:'));
+  console.log();
+
+  sizes.forEach((dir, i) => {
+    const barLength = Math.round((dir.size / maxSize) * barWidth);
+    const bar = chalk.cyan('\u2588'.repeat(barLength)) + chalk.gray('\u2591'.repeat(barWidth - barLength));
+    const sizeStr = formatSize(dir.size).padStart(10);
+
+    console.log(`  ${chalk.white(dir.name.padEnd(15))} ${bar} ${chalk.green(sizeStr)}`);
+  });
+
+  console.log();
+
+  // Show Library breakdown
+  console.log(chalk.white('  Library Breakdown:'));
+  console.log();
+
+  const libraryDirs = [
+    { path: path.join(HOME, 'Library/Caches'), name: 'Caches' },
+    { path: path.join(HOME, 'Library/Application Support'), name: 'App Support' },
+    { path: path.join(HOME, 'Library/Containers'), name: 'Containers' },
+    { path: path.join(HOME, 'Library/Developer'), name: 'Developer' },
+    { path: path.join(HOME, 'Library/Logs'), name: 'Logs' }
+  ];
+
+  for (const dir of libraryDirs) {
+    if (fs.existsSync(dir.path)) {
+      const size = getSize(dir.path);
+      const sizeStr = formatSize(size).padStart(10);
+      console.log(`    ${figures.bullet} ${chalk.dim(dir.name.padEnd(20))} ${chalk.yellow(sizeStr)}`);
+    }
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// PRIVACY SWEEP
+// ============================================================================
+
+async function privacySweep() {
+  header();
+  sectionHeader(MSG.OPT_PRIVACY);
+
+  const items = [];
+
+  // Browser data
+  const browserPaths = [
+    { path: '~/Library/Cookies', name: 'System Cookies' },
+    { path: '~/Library/Application Support/Google/Chrome/Default/Cookies', name: 'Chrome Cookies' },
+    { path: '~/Library/Application Support/Google/Chrome/Default/History', name: 'Chrome History' },
+    { path: '~/Library/Application Support/Google/Chrome/Default/Login Data', name: 'Chrome Saved Logins' },
+    { path: '~/Library/Safari/History.db', name: 'Safari History' },
+    { path: '~/Library/Safari/Downloads.plist', name: 'Safari Downloads' },
+    { path: '~/Library/Safari/LocalStorage', name: 'Safari Local Storage' },
+    { path: '~/Library/Application Support/Firefox/Profiles', name: 'Firefox Profile Data' },
+    { path: '~/.recently-used', name: 'Recent Files' },
+    { path: '~/Library/Application Support/com.apple.sharedfilelist', name: 'Recent Items' },
+    { path: '~/Library/Preferences/com.apple.recentitems.plist', name: 'Recent Items Plist' }
+  ];
+
+  console.log(chalk.white('  Privacy-sensitive items found:'));
+  console.log();
+
+  browserPaths.forEach((item, i) => {
+    const fullPath = item.path.replace(/^~/, HOME);
+    if (fs.existsSync(fullPath)) {
+      const size = getSize(item.path);
+      items.push({ ...item, fullPath, size });
+      console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${item.name.padEnd(30)} ${chalk.dim(formatSize(size))}`);
+    }
+  });
+
+  if (items.length === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log();
+  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [a=${MSG.ALL}/n=${MSG.CANCEL}]:`));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    await pressEnter();
+    return;
+  }
+
+  let cleaned = 0;
+
+  if (choice.toLowerCase() === 'a') {
+    const spinner = ora(MSG.CLEANING).start();
+
+    for (const item of items) {
+      if (deleteItem(item.fullPath)) {
+        cleaned += item.size;
+      }
+    }
+
+    spinner.succeed(chalk.green(`${MSG.PRIVACY_CLEANED}: ${formatSize(cleaned)}`));
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// MEMORY OPTIMIZER
+// ============================================================================
+
+async function memoryOptimizer() {
+  header();
+  sectionHeader(MSG.OPT_MEMORY);
+
+  console.log(chalk.white('  Current Memory Status:'));
+  console.log();
+  console.log(`  ${figures.bullet} RAM: ${systemStats.ramUsedPercent}% ${MSG.IN_USE}`);
+  console.log(`  ${figures.bullet} Swap: ${systemStats.swapUsed} MB ${MSG.IN_USE}`);
+  console.log();
+
+  console.log(chalk.yellow(`  ${figures.warning} This will run 'sudo purge' to free inactive memory.`));
+  console.log(chalk.dim('  You may need to enter your password.'));
+  console.log();
+
+  const confirm = await prompt(`  ${chalk.white('Continue? [y/n]:')} `);
+
+  if (confirm.toLowerCase() !== 'y') {
+    await pressEnter();
+    return;
+  }
+
+  if (DRY_RUN) {
+    console.log(chalk.yellow(`  ${figures.info} [DRY-RUN] Would run: sudo purge`));
+  } else {
+    const spinner = ora('Freeing memory...').start();
+
     try {
-      execSync(`rm -rf "${fullPath}"`, { stdio: 'ignore' });
-      console.log(`  ${c.green}✓${c.reset} ${name}`);
-      return true;
+      execSync('sudo purge', { stdio: 'inherit' });
+      spinner.succeed(chalk.green(MSG.MEMORY_FREED));
     } catch (e) {
-      return false;
-    }
-  }
-  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' },
-];
+      spinner.fail(chalk.red('Failed to free memory'));
+    }
+  }
+
+  // Refresh stats
+  getSystemStats();
+  console.log();
+  console.log(chalk.white('  Updated Memory Status:'));
+  console.log(`  ${figures.bullet} RAM: ${systemStats.ramUsedPercent}% ${MSG.IN_USE}`);
+  console.log(`  ${figures.bullet} Swap: ${systemStats.swapUsed} MB ${MSG.IN_USE}`);
+
+  await pressEnter();
+}
+
+// ============================================================================
+// BENCHMARK MODE
+// ============================================================================
+
+async function benchmarkMode() {
+  header();
+  sectionHeader(MSG.OPT_BENCHMARK);
+
+  console.log(chalk.white('  Running system benchmark...'));
+  console.log();
+
+  const results = {
+    timestamp: new Date().toISOString(),
+    tests: []
+  };
+
+  // Disk read speed
+  const spinner1 = ora('Testing disk read speed...').start();
+  const diskStart = Date.now();
+  exec('dd if=/dev/zero of=/tmp/benchmark_test bs=1m count=100 2>/dev/null');
+  const diskWrite = Date.now() - diskStart;
+
+  const diskReadStart = Date.now();
+  exec('dd if=/tmp/benchmark_test of=/dev/null bs=1m 2>/dev/null');
+  const diskRead = Date.now() - diskReadStart;
 
-let totalClean = 0;
+  exec('rm /tmp/benchmark_test');
+  spinner1.succeed(`Disk: Write ${Math.round(100000 / diskWrite)} MB/s, Read ${Math.round(100000 / diskRead)} MB/s`);
 
-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}`);
+  results.tests.push({
+    name: 'Disk Write',
+    value: Math.round(100000 / diskWrite),
+    unit: 'MB/s'
+  });
+  results.tests.push({
+    name: 'Disk Read',
+    value: Math.round(100000 / diskRead),
+    unit: 'MB/s'
+  });
+
+  // CPU benchmark
+  const spinner2 = ora('Testing CPU performance...').start();
+  const cpuStart = Date.now();
+  let cpuTest = 0;
+  for (let i = 0; i < 10000000; i++) {
+    cpuTest += Math.sqrt(i);
   }
-});
+  const cpuTime = Date.now() - cpuStart;
+  spinner2.succeed(`CPU: ${cpuTime}ms for 10M sqrt operations`);
 
-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();
+  results.tests.push({
+    name: 'CPU (10M sqrt)',
+    value: cpuTime,
+    unit: 'ms'
+  });
 
-// 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();
+  // Memory benchmark
+  const spinner3 = ora('Testing memory allocation...').start();
+  const memStart = Date.now();
+  const testArrays = [];
+  for (let i = 0; i < 100; i++) {
+    testArrays.push(new Array(1000000).fill(Math.random()));
+  }
+  const memTime = Date.now() - memStart;
+  spinner3.succeed(`Memory: ${memTime}ms to allocate 100MB`);
 
-// npm cache
-try {
-  execSync('npm cache clean --force 2>/dev/null', { stdio: 'ignore' });
-  console.log(`  ${c.green}✓${c.reset} npm cache`);
-} catch (e) {}
+  results.tests.push({
+    name: 'Memory (100MB alloc)',
+    value: memTime,
+    unit: 'ms'
+  });
 
-// Limpar paths
-cleanPaths.forEach(item => {
-  cleanPath(item.path, item.name);
-});
+  // Save results
+  const benchmarkLine = `${results.timestamp} | Disk: W${Math.round(100000 / diskWrite)}MB/s R${Math.round(100000 / diskRead)}MB/s | CPU: ${cpuTime}ms | Mem: ${memTime}ms\n`;
+  fs.appendFileSync(BENCHMARK_FILE, benchmarkLine);
 
-// 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) {
-      versions.slice(1).forEach(v => {
-        fs.rmSync(path.join(claudeVersionsPath, v), { recursive: true, force: true });
+  console.log();
+  console.log(chalk.green(`${figures.tick} ${MSG.BENCHMARK_COMPLETE}`));
+
+  // Show history if available
+  if (fs.existsSync(BENCHMARK_FILE)) {
+    const history = fs.readFileSync(BENCHMARK_FILE, 'utf8').split('\n').filter(l => l.trim());
+    if (history.length > 1) {
+      console.log();
+      console.log(chalk.white('  Recent benchmarks:'));
+      history.slice(-5).forEach(line => {
+        console.log(chalk.dim(`  ${line}`));
       });
-      console.log(`  ${c.green}✓${c.reset} Claude (${versions.length - 1} versões antigas)`);
     }
-  } catch (e) {}
+  }
+
+  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) {}
+// ============================================================================
+// SCHEDULER (LAUNCHD)
+// ============================================================================
 
-// 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();
+async function scheduler() {
+  header();
+  sectionHeader(MSG.OPT_SCHEDULER);
+
+  const plistPath = path.join(HOME, 'Library/LaunchAgents/com.aris.mac-cleaner.plist');
+  const isScheduled = fs.existsSync(plistPath);
+
+  console.log(chalk.white('  Cleanup Scheduler'));
+  console.log();
+
+  if (isScheduled) {
+    console.log(chalk.green(`  ${figures.tick} Scheduled cleanup is ACTIVE`));
+    console.log();
+    console.log(`  ${chalk.cyan('[1]')} Remove schedule`);
+    console.log(`  ${chalk.cyan('[2]')} View current schedule`);
+  } else {
+    console.log(chalk.yellow(`  ${figures.info} No scheduled cleanup configured`));
+    console.log();
+    console.log(`  ${chalk.cyan('[1]')} Schedule daily cleanup (midnight)`);
+    console.log(`  ${chalk.cyan('[2]')} Schedule weekly cleanup (Sunday midnight)`);
+  }
+
+  console.log();
+  console.log(`  ${chalk.cyan('[0]')} ${MSG.BACK}`);
+  console.log();
+
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  if (isScheduled) {
+    if (choice === '1') {
+      // Remove schedule
+      try {
+        exec(`launchctl unload "${plistPath}" 2>/dev/null`);
+        fs.unlinkSync(plistPath);
+        console.log(chalk.green(`  ${figures.tick} ${MSG.SCHEDULE_REMOVED}`));
+      } catch (e) {
+        console.log(chalk.red(`  ${figures.cross} Failed to remove schedule`));
+      }
+    } else if (choice === '2') {
+      // View schedule
+      const content = fs.readFileSync(plistPath, 'utf8');
+      console.log();
+      console.log(chalk.dim(content));
+    }
+  } else {
+    if (choice === '1' || choice === '2') {
+      const isDaily = choice === '1';
+
+      const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.aris.mac-cleaner</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${process.execPath}</string>
+        <string>${__filename}</string>
+        <string>--quick</string>
+    </array>
+    <key>StartCalendarInterval</key>
+    <dict>
+        <key>Hour</key>
+        <integer>0</integer>
+        <key>Minute</key>
+        <integer>0</integer>
+        ${isDaily ? '' : '<key>Weekday</key>\n        <integer>0</integer>'}
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${path.join(CONFIG_DIR, 'scheduled-cleanup.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(CONFIG_DIR, 'scheduled-cleanup-error.log')}</string>
+</dict>
+</plist>`;
+
+      try {
+        fs.writeFileSync(plistPath, plistContent);
+        exec(`launchctl load "${plistPath}"`);
+        console.log(chalk.green(`  ${figures.tick} ${isDaily ? MSG.SCHEDULED_DAILY : MSG.SCHEDULED_WEEKLY}`));
+      } catch (e) {
+        console.log(chalk.red(`  ${figures.cross} Failed to create schedule`));
+      }
+    }
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// EXPORT HTML REPORT
+// ============================================================================
+
+async function exportHtmlReport() {
+  header();
+  sectionHeader(MSG.OPT_EXPORT);
+
+  getSystemStats();
+  const health = calculateHealthScore();
+  const recs = getSmartRecommendations();
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const reportPath = path.join(REPORTS_DIR, `report-${timestamp}.html`);
+
+  // Read history
+  let historyData = [];
+  if (fs.existsSync(HISTORY_FILE)) {
+    historyData = fs.readFileSync(HISTORY_FILE, 'utf8').split('\n').filter(l => l.trim()).slice(-30);
+  }
+
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Aris Mac Cleaner Report - ${new Date().toLocaleDateString()}</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            color: #fff;
+            min-height: 100vh;
+            padding: 40px;
+        }
+        .container { max-width: 900px; margin: 0 auto; }
+        .header {
+            text-align: center;
+            margin-bottom: 40px;
+            padding: 30px;
+            background: rgba(255,255,255,0.1);
+            border-radius: 20px;
+            backdrop-filter: blur(10px);
+        }
+        .header h1 {
+            font-size: 2.5em;
+            background: linear-gradient(90deg, #00d2ff, #3a7bd5);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .header p { color: #888; margin-top: 10px; }
+        .card {
+            background: rgba(255,255,255,0.05);
+            border-radius: 15px;
+            padding: 25px;
+            margin-bottom: 20px;
+            border: 1px solid rgba(255,255,255,0.1);
+        }
+        .card h2 {
+            color: #00d2ff;
+            margin-bottom: 20px;
+            font-size: 1.3em;
+        }
+        .stat-row {
+            display: flex;
+            justify-content: space-between;
+            padding: 12px 0;
+            border-bottom: 1px solid rgba(255,255,255,0.05);
+        }
+        .stat-row:last-child { border-bottom: none; }
+        .stat-label { color: #888; }
+        .stat-value { font-weight: bold; }
+        .health-score {
+            text-align: center;
+            padding: 40px;
+        }
+        .health-score .score {
+            font-size: 4em;
+            font-weight: bold;
+            background: linear-gradient(90deg, ${health.score >= 80 ? '#00ff87, #60efff' : health.score >= 60 ? '#ffcc00, #ff6600' : '#ff0000, #ff6666'});
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .health-score .label {
+            color: #888;
+            font-size: 1.2em;
+            margin-top: 10px;
+        }
+        .recommendation {
+            padding: 15px;
+            margin: 10px 0;
+            border-radius: 10px;
+            background: rgba(255,204,0,0.1);
+            border-left: 3px solid #ffcc00;
+        }
+        .recommendation.high {
+            background: rgba(255,0,0,0.1);
+            border-left-color: #ff4444;
+        }
+        .history-item {
+            font-family: monospace;
+            font-size: 0.9em;
+            padding: 8px;
+            color: #888;
+        }
+        .footer {
+            text-align: center;
+            margin-top: 40px;
+            color: #666;
+            font-size: 0.9em;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>ARIS MAC CLEANER</h1>
+            <p>System Report - ${new Date().toLocaleString()}</p>
+        </div>
+
+        <div class="card health-score">
+            <div class="score">${health.score}/100</div>
+            <div class="label">${MSG.HEALTH_SCORE} - ${health.text}</div>
+        </div>
+
+        <div class="card">
+            <h2>${MSG.DIAGNOSE}</h2>
+            <div class="stat-row">
+                <span class="stat-label">${MSG.DISK}</span>
+                <span class="stat-value">${systemStats.diskFree}GB ${MSG.FREE_OF} ${systemStats.diskTotal}GB (${systemStats.diskPercent}% ${MSG.IN_USE})</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">${MSG.RAM}</span>
+                <span class="stat-value">${systemStats.ramUsedPercent}% ${MSG.IN_USE}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">${MSG.SWAP}</span>
+                <span class="stat-value">${systemStats.swapUsed} MB ${MSG.IN_USE}</span>
+            </div>
+            <div class="stat-row">
+                <span class="stat-label">${MSG.CPU}</span>
+                <span class="stat-value">${systemStats.cpuUsed}% ${MSG.IN_USE}</span>
+            </div>
+        </div>
+
+        ${recs.length > 0 ? `
+        <div class="card">
+            <h2>${MSG.RECOMMENDATIONS}</h2>
+            ${recs.map(r => `<div class="recommendation ${r.priority}">${r.text}</div>`).join('')}
+        </div>
+        ` : ''}
+
+        ${historyData.length > 0 ? `
+        <div class="card">
+            <h2>${MSG.HISTORY}</h2>
+            ${historyData.map(h => `<div class="history-item">${h}</div>`).join('')}
+        </div>
+        ` : ''}
+
+        ${lastCleanupResults ? `
+        <div class="card">
+            <h2>Last Cleanup</h2>
+            <div class="stat-row">
+                <span class="stat-label">${MSG.FREED}</span>
+                <span class="stat-value">${formatSize(lastCleanupResults.freed)}</span>
+            </div>
+        </div>
+        ` : ''}
+
+        <div class="footer">
+            <p>Generated by Aris Mac Cleaner v${VERSION}</p>
+            <p>por Salvador Reis</p>
+        </div>
+    </div>
+</body>
+</html>`;
+
+  fs.writeFileSync(reportPath, html);
+
+  console.log(chalk.green(`  ${figures.tick} ${MSG.REPORT_EXPORTED}`));
+  console.log(chalk.dim(`  ${reportPath}`));
+  console.log();
+
+  const open = await prompt(`  Open in browser? [y/n]: `);
+  if (open.toLowerCase() === 'y') {
+    exec(`open "${reportPath}"`);
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// STATISTICS WITH ASCII CHART
+// ============================================================================
+
+async function showStatistics() {
+  header();
+  sectionHeader(MSG.OPT_STATS);
+
+  if (!fs.existsSync(HISTORY_FILE)) {
+    console.log(`  ${chalk.dim(MSG.NO_HISTORY)}`);
+    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;
+  const freedValues = [];
+
+  monthLines.forEach(line => {
+    const freedMatch = line.match(/(\d+)\s*MB/);
+    const scoreMatch = line.match(/Score:\s*(\d+)/);
+    if (freedMatch) {
+      const freed = parseInt(freedMatch[1]);
+      monthFreed += freed;
+      freedValues.push(freed);
+    }
+    if (scoreMatch) monthScoreSum += parseInt(scoreMatch[1]);
+  });
+
+  const monthAvg = monthCleanups > 0 ? Math.round(monthScoreSum / monthCleanups) : 0;
+
+  console.log(chalk.white(`  ${MSG.THIS_MONTH}:`));
+  console.log(`  ${figures.bullet} ${MSG.CLEANINGS}: ${chalk.cyan(monthCleanups)}`);
+  console.log(`  ${figures.bullet} ${MSG.TOTAL} ${MSG.FREED}: ${chalk.green(formatSize(monthFreed))}`);
+  console.log(`  ${figures.bullet} ${MSG.AVG_SCORE}: ${chalk.yellow(monthAvg + '/100')}`);
+  console.log();
+
+  // Show ASCII chart if we have enough data
+  if (freedValues.length >= 3) {
+    console.log(chalk.white('  Space Freed (MB) - Last cleanups:'));
+    console.log();
+
+    try {
+      const chartData = freedValues.slice(-15);
+      const chart = asciichart.plot(chartData, {
+        height: 8,
+        colors: [asciichart.cyan],
+        format: (x) => String(Math.round(x)).padStart(6)
+      });
+      chart.split('\n').forEach(line => console.log('  ' + line));
+    } catch (e) {
+      // Fallback if asciichart fails
+      freedValues.slice(-10).forEach((v, i) => {
+        const bar = chalk.cyan('\u2588'.repeat(Math.min(Math.round(v / 50), 40)));
+        console.log(`  ${bar} ${v} MB`);
+      });
+    }
+    console.log();
+  }
+
+  console.log(chalk.white(`  ${MSG.HISTORY}:`));
+  history.slice(-10).forEach(line => {
+    console.log(chalk.dim(`  ${line}`));
+  });
+
+  await pressEnter();
+}
+
+// ============================================================================
+// QUICK CLEAN (ENHANCED)
+// ============================================================================
+
+async function quickClean() {
+  header();
+  getSystemStats();
+  showDiagnostics();
+  showRecommendations();
+  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;
+    }
+  }
+
+  const spinner = ora(MSG.SCANNING).start();
+
+  // 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 {
+      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;
+    }
+  }
+
+  // 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');
+    });
+  }
+
+  spinner.stop();
+
+  if (items.length === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${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(`  ${chalk.white('  ' + catName)} ${chalk.dim('(' + formatSize(catSize) + ')')}`);
+
+    catItems.forEach(item => {
+      const idx = items.indexOf(item) + 1;
+      console.log(`  ${chalk.cyan('[' + String(idx).padStart(2) + ']')} ${item.name.padEnd(35)} ${chalk.dim(String(item.size).padStart(6) + ' MB')}`);
+    });
+    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(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalSize))}`);
+  console.log();
+
+  // Selection
+  sectionHeader(MSG.SELECT_DELETE);
+  console.log(chalk.dim(`  a = ${MSG.ALL} | n = ${MSG.CANCEL} | 1,3,5 | 1-5 | 1-5,8,10`));
+  console.log();
+
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    console.log(`  ${chalk.yellow(MSG.CANCEL)}`);
+    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;
+      }
+    });
+  }
+
+  // Create backup
+  const selectedItems = items.filter(i => i.selected);
+  if (selectedItems.length > 0 && !DRY_RUN) {
+    const backupFile = createBackup(selectedItems);
+    console.log(chalk.dim(`  ${figures.info} ${MSG.BACKUP_CREATED}: ${path.basename(backupFile)}`));
+    console.log();
+  }
+
+  // Clean with progress bar
+  console.log();
+  sectionHeader(MSG.CLEANING);
+
+  const progressBar = createProgressBar(selectedItems.length);
+  progressBar.start(selectedItems.length, 0);
+
+  let cleanedSize = 0;
+  const claudeVersionsPathLocal = path.join(HOME, '.local/share/claude/versions');
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item.selected) continue;
+
+    if (item.path === 'CLAUDE_VERSIONS') {
+      if (!DRY_RUN) {
+        const versions = fs.readdirSync(claudeVersionsPathLocal).sort().reverse();
+        versions.slice(1).forEach(v => {
+          try {
+            deleteItem(path.join(claudeVersionsPathLocal, v));
+          } catch (e) {}
+        });
+      }
+      cleanedSize += item.size;
+    } else if (item.path === 'OLD_DOWNLOADS') {
+      if (!DRY_RUN) {
+        exec('find ~/Downloads -name "*.dmg" -mtime +7 -delete 2>/dev/null');
+        exec('find ~/Downloads -name "*.zip" -mtime +30 -delete 2>/dev/null');
+      }
+      cleanedSize += item.size;
+    } else if (fs.existsSync(item.path)) {
+      if (deleteItem(item.path)) {
+        cleanedSize += item.size;
+      }
+    }
+
+    progressBar.increment();
+  }
+
+  progressBar.stop();
+
+  // npm cache
+  if (!DRY_RUN) {
+    try {
+      execSync('npm cache clean --force 2>/dev/null', { stdio: 'ignore' });
+    } catch (e) {}
+  }
+
+  console.log();
+
+  // Show cleaned items
+  selectedItems.forEach(item => {
+    console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+  });
+
+  console.log();
+  getSystemStats();
+  showFinalReport(cleanedSize);
+  await pressEnter();
+}
+
+// ============================================================================
+// FIND LARGE FILES
+// ============================================================================
+
+async function findLargeFiles() {
+  header();
+  sectionHeader(`${MSG.LARGE_FILES} (>100MB)`);
+
+  const spinner = ora(MSG.SCANNING).start();
+
+  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 });
+  });
+
+  spinner.stop();
+
+  if (files.length === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${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(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${chalk.dim(String(file.size).padStart(6) + ' MB')}  ${displayFile}`);
+  });
+
+  console.log();
+  console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalLarge))} ${chalk.dim('(' + files.length + ' files)')}`);
+  console.log();
+
+  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/a/n]:`));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  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;
+
+    if (deleteItem(files[i].path)) {
+      console.log(`  ${chalk.green(figures.tick)} Deleted: ${path.basename(files[i].path)}`);
+      deletedSize += files[i].size;
+    }
+  }
+
+  console.log();
+  console.log(`  ${chalk.green(MSG.FREED + ': ' + formatSize(deletedSize))}`);
+
+  playNotificationSound();
+  await pressEnter();
+}
+
+// ============================================================================
+// FIND DUPLICATES
+// ============================================================================
+
+async function findDuplicates() {
+  header();
+  sectionHeader(MSG.DUPLICATES);
+
+  const spinner = ora(`${MSG.SCANNING} (this may take a while)...`).start();
+
+  // 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) {}
+  });
+
+  spinner.text = MSG.HASHING;
+
+  // 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) {}
+    }
+  }
+
+  spinner.stop();
+
+  // 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(`  ${chalk.white(MSG.GROUP + ' ' + groupNum)} ${chalk.dim('(' + fileSize + ' MB ' + MSG.EACH + ')')}`);
+
+    fileList.forEach((file, idx) => {
+      let display = file.replace(HOME, '~');
+      if (display.length > 50) display = '...' + display.slice(-47);
+      console.log(`    ${chalk.cyan('[' + (idx + 1) + ']')} ${display}`);
+      allDups.push(file);
+    });
+    console.log();
+
+    if (groupNum >= 10) break;
+  }
+
+  if (groupNum === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalDupSize))} ${MSG.IN_DUPLICATES}`);
+  console.log();
+  console.log(chalk.dim(`  ${MSG.SELECT_KEEP}`));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  console.log(`  ${chalk.yellow(MSG.FEATURE_PROGRESS)}`);
+  await pressEnter();
+}
+
+// ============================================================================
+// UNINSTALL APPS
+// ============================================================================
+
+async function uninstallApps() {
+  header();
+  sectionHeader(MSG.UNINSTALL);
+
+  const spinner = ora(MSG.SCANNING).start();
+
+  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;
+  }
+
+  spinner.stop();
+
+  header();
+  sectionHeader(MSG.UNINSTALL);
+
+  if (apps.length === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  apps.forEach((app, i) => {
+    console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${app.name.padEnd(25)} ${chalk.dim('(' + String(app.appSize).padStart(3) + ' MB ' + MSG.APP_SIZE + ' + ' + String(app.dataSize).padStart(3) + ' MB ' + MSG.DATA_SIZE + ')')}`);
+  });
+
+  console.log();
+  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/n]:`));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  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(`  ${chalk.yellow(MSG.DELETING + ' ' + app.name + '...')}`);
+
+    // Remove app data
+    if (app.bundleId && !DRY_RUN) {
+      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)) deleteItem(dp);
+        } catch (e) {}
+      });
+    }
+
+    // Remove app
+    if (deleteItem(app.path)) {
+      console.log(`  ${chalk.green(figures.tick)} ${app.name} ${MSG.REMOVED}`);
+    } else {
+      console.log(`  ${chalk.red(MSG.NEED_SUDO)}`);
+      console.log(`  ${chalk.dim('sudo rm -rf "' + app.path + '"')}`);
+    }
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// MANAGE STARTUP
+// ============================================================================
+
+async function manageStartup() {
+  header();
+  sectionHeader(MSG.STARTUP_ITEMS);
+
+  console.log(`  ${chalk.white(MSG.STARTUP_ITEMS + ':')}`);
+
+  // 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(`  ${chalk.cyan('[' + (idx + 1) + ']')} ${chalk.green(figures.tick)} ${item} ${chalk.dim('(' + MSG.ENABLED + ')')}`);
+    });
+  } else {
+    console.log(chalk.dim('  No login items found'));
+  }
+
+  console.log();
+  console.log(`  ${chalk.white(MSG.LAUNCH_AGENTS + ':')}`);
+
+  // 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 ?
+        `${chalk.green(figures.tick)} ${MSG.ENABLED}` :
+        `${chalk.red(figures.cross)} ${MSG.DISABLED}`;
+
+      console.log(`  ${chalk.cyan('[' + idx + ']')} ${status} ${chalk.dim(name)}`);
+      idx++;
+    }
+  }
+
+  console.log();
+  console.log(chalk.dim("  Enter number to toggle, 'd' to disable all, or 'n' to go back"));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  if (choice.toLowerCase() === 'd') {
+    exec(`osascript -e 'tell application "System Events" to delete every login item' 2>/dev/null`);
+    console.log(`  ${chalk.green(figures.tick)} All login items disabled`);
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// 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(`  ${chalk.white('Chrome:')}`);
+  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(`  ${chalk.white('Safari:')}`);
+  addBrowserItem('~/Library/Caches/com.apple.Safari', 'Safari Cache');
+  addBrowserItem('~/Library/Safari/LocalStorage', 'Safari Local Storage');
+
+  console.log(`  ${chalk.white('Firefox:')}`);
+  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(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${item.name.padEnd(30)} ${chalk.dim(String(item.size).padStart(6) + ' MB')}`);
+  });
+
+  if (items.length === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log();
+  console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalBrowser))}`);
+  console.log();
+
+  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/a/n]:`));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  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;
+    if (deleteItem(item.path)) {
+      console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+      cleaned += item.size;
+    }
+  }
+
+  console.log();
+  console.log(`  ${chalk.green(MSG.FREED + ': ' + formatSize(cleaned))}`);
+
+  playNotificationSound();
+  await pressEnter();
+}
+
+// ============================================================================
+// KILL PROCESSES
+// ============================================================================
+
+async function killProcesses() {
+  header();
+  sectionHeader(MSG.PROCESS_MEM);
+
+  console.log(`  ${chalk.white(MSG.PROCESS_MEM + ':')}`);
+
+  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(`  ${chalk.cyan('[' + String(procs.length).padStart(2) + ']')} ${name.padEnd(30)} ${chalk.red(memMB + ' MB RAM')}`);
+
+    if (procs.length >= 10) break;
+  }
+
+  if (procs.length === 0) {
+    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  console.log();
+  console.log(chalk.dim(`  ${MSG.KILL} process [number/n]:`));
+  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+  if (choice.toLowerCase() === 'n' || choice === '') {
+    await pressEnter();
+    return;
+  }
+
+  const idx = parseInt(choice) - 1;
+  if (idx >= 0 && idx < procs.length) {
+    const proc = procs[idx];
+
+    if (DRY_RUN) {
+      console.log(chalk.yellow(`  ${figures.info} [DRY-RUN] Would kill: ${proc.name} (PID: ${proc.pid})`));
+    } else {
+      try {
+        process.kill(parseInt(proc.pid), 'SIGKILL');
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.KILLED}: ${proc.name} (PID: ${proc.pid})`);
+      } catch (e) {
+        console.log(`  ${chalk.red(figures.cross)} ${MSG.FAILED_KILL} ${proc.name}`);
+      }
+    }
+  }
+
+  await pressEnter();
+}
+
+// ============================================================================
+// SETTINGS
+// ============================================================================
+
+async function showSettings() {
+  while (true) {
+    header();
+    sectionHeader(MSG.OPT_SETTINGS);
+
+    const currentLang = LANG_CODE === 'en' ? 'EN' : 'PT';
+
+    console.log(`  ${chalk.cyan('[1]')} ${MSG.EXCLUSIONS}`);
+    console.log(`  ${chalk.cyan('[2]')} ${MSG.CUSTOM_PATHS}`);
+    console.log(`  ${chalk.cyan('[3]')} ${MSG.CHANGE_LANG} (current: ${currentLang})`);
+    console.log(`  ${chalk.cyan('[4]')} ${MSG.RESET_DEFAULTS}`);
+    console.log(`  ${chalk.cyan('[5]')} ${DRY_RUN ? chalk.green(figures.tick) : figures.radioOff} Dry-Run Mode`);
+    console.log(`  ${chalk.cyan('[6]')} ${SECURE_DELETE ? chalk.green(figures.tick) : figures.radioOff} Secure Delete Mode`);
+    console.log(`  ${chalk.cyan('[7]')} View Backups`);
+    console.log();
+    console.log(`  ${chalk.cyan('[0]')} ${MSG.BACK}`);
+    console.log();
+
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+    switch (choice) {
+      case '1':
+        // Manage exclusions
+        header();
+        sectionHeader(MSG.EXCLUSIONS);
+
+        console.log(`  ${chalk.white(MSG.CURRENT_EXCLUSIONS + ':')}`);
+        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(chalk.dim('  None'));
+        }
+        console.log();
+        console.log(chalk.dim(`  ${MSG.ENTER_PATH}:`));
+
+        const newExclusion = await prompt(`  ${chalk.white(MSG.PATH + ':')} `);
+
+        if (newExclusion === 'c') {
+          if (fs.existsSync(EXCLUSIONS_FILE)) fs.unlinkSync(EXCLUSIONS_FILE);
+          console.log(`  ${chalk.green(figures.tick)} Exclusions ${MSG.CLEARED}`);
+        } else if (newExclusion !== 'n' && newExclusion) {
+          fs.appendFileSync(EXCLUSIONS_FILE, newExclusion + '\n');
+          console.log(`  ${chalk.green(figures.tick)} ${MSG.ADDED}: ${newExclusion}`);
+        }
+        await pressEnter();
+        break;
+
+      case '2':
+        // Custom paths
+        header();
+        sectionHeader(MSG.CUSTOM_PATHS);
+
+        console.log(`  ${chalk.white(MSG.CURRENT_PATHS + ':')}`);
+        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(chalk.dim('  None'));
+        }
+        console.log();
+        console.log(chalk.dim(`  ${MSG.ENTER_PATH}:`));
+
+        const newPath = await prompt(`  ${chalk.white(MSG.PATH + ':')} `);
+
+        if (newPath === 'c') {
+          if (fs.existsSync(CUSTOM_PATHS_FILE)) fs.unlinkSync(CUSTOM_PATHS_FILE);
+          console.log(`  ${chalk.green(figures.tick)} Custom paths ${MSG.CLEARED}`);
+        } else if (newPath !== 'n' && newPath) {
+          fs.appendFileSync(CUSTOM_PATHS_FILE, newPath + '\n');
+          console.log(`  ${chalk.green(figures.tick)} ${MSG.ADDED}: ${newPath}`);
+        }
+        await pressEnter();
+        break;
+
+      case '3':
+        // Change language
+        const newLang = LANG_CODE === 'pt' ? 'en' : 'pt';
+        fs.writeFileSync(LANGUAGE_FILE, newLang);
+        console.log(`  ${chalk.green(figures.tick)} ${newLang === 'en' ? MSG.LANG_CHANGED_EN : MSG.LANG_CHANGED_PT}`);
+        await pressEnter();
+        // Restart to apply language change
+        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(`  ${chalk.green(figures.tick)} ${MSG.SETTINGS_RESET}`);
+        await pressEnter();
+        // Restart to apply changes
+        spawn(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+        process.exit(0);
+        break;
+
+      case '5':
+        DRY_RUN = !DRY_RUN;
+        console.log(`  ${chalk.green(figures.tick)} Dry-Run Mode: ${DRY_RUN ? 'ON' : 'OFF'}`);
+        await pressEnter();
+        break;
+
+      case '6':
+        SECURE_DELETE = !SECURE_DELETE;
+        console.log(`  ${chalk.green(figures.tick)} Secure Delete Mode: ${SECURE_DELETE ? 'ON' : 'OFF'}`);
+        await pressEnter();
+        break;
+
+      case '7':
+        // View backups
+        header();
+        sectionHeader('Backups');
+
+        const backups = listBackups();
+        if (backups.length === 0) {
+          console.log(chalk.dim('  No backups found'));
+        } else {
+          backups.forEach((b, i) => {
+            console.log(`  ${chalk.cyan('[' + (i + 1) + ']')} ${b}`);
+          });
+        }
+        await pressEnter();
+        break;
+
+      case '0':
+        return;
+
+      default:
+        break;
+    }
+  }
+}
+
+// ============================================================================
+// MAIN MENU
+// ============================================================================
+
+async function mainMenu() {
+  while (true) {
+    header();
+
+    // Show update notification
+    await showUpdateNotification();
+
+    // Main options
+    console.log(chalk.white('  CLEANING'));
+    console.log(`  ${chalk.cyan('[1]')}  ${MSG.OPT_QUICK}`);
+    console.log(`  ${chalk.cyan('[2]')}  ${MSG.OPT_LARGE}`);
+    console.log(`  ${chalk.cyan('[3]')}  ${MSG.OPT_DUPLICATES}`);
+    console.log(`  ${chalk.cyan('[4]')}  ${MSG.OPT_APPS}`);
+    console.log(`  ${chalk.cyan('[5]')}  ${MSG.OPT_BROWSERS}`);
+    console.log(`  ${chalk.cyan('[6]')}  ${MSG.OPT_PRIVACY}`);
+    console.log();
+
+    console.log(chalk.white('  SYSTEM'));
+    console.log(`  ${chalk.cyan('[7]')}  ${MSG.OPT_STARTUP}`);
+    console.log(`  ${chalk.cyan('[8]')}  ${MSG.OPT_PROCESSES}`);
+    console.log(`  ${chalk.cyan('[9]')}  ${MSG.OPT_MEMORY}`);
+    console.log(`  ${chalk.cyan('[10]')} ${MSG.OPT_DISK}`);
+    console.log();
+
+    console.log(chalk.white('  TOOLS'));
+    console.log(`  ${chalk.cyan('[11]')} ${MSG.OPT_BENCHMARK}`);
+    console.log(`  ${chalk.cyan('[12]')} ${MSG.OPT_SCHEDULER}`);
+    console.log(`  ${chalk.cyan('[13]')} ${MSG.OPT_EXPORT}`);
+    console.log(`  ${chalk.cyan('[14]')} ${MSG.OPT_STATS}`);
+    console.log(`  ${chalk.cyan('[15]')} ${MSG.OPT_SETTINGS}`);
+    console.log();
+
+    console.log(`  ${chalk.cyan('[0]')}  ${MSG.OPT_EXIT}`);
+    console.log();
+
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+    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 cleanBrowsers(); break;
+      case '6': await privacySweep(); break;
+      case '7': await manageStartup(); break;
+      case '8': await killProcesses(); break;
+      case '9': await memoryOptimizer(); break;
+      case '10': await diskAnalyzer(); break;
+      case '11': await benchmarkMode(); break;
+      case '12': await scheduler(); break;
+      case '13': await exportHtmlReport(); break;
+      case '14': await showStatistics(); break;
+      case '15': await showSettings(); break;
+      case '0':
+        clearScreen();
+        console.log();
+        console.log(gradient.pastel.multiline(`
+  Thank you for using Aris Mac Cleaner!
+
+  por Salvador Reis ${figures.bullet} github.com/salvadorreis
+`));
+        console.log();
+        process.exit(0);
+        break;
+      default:
+        console.log(`  ${chalk.red(MSG.INVALID)}`);
+        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);
+
+// Parse flags
+if (args.includes('--dry-run')) {
+  DRY_RUN = true;
+}
+
+if (args.includes('--secure')) {
+  SECURE_DELETE = true;
+}
+
+if (args.includes('--version') || args.includes('-v')) {
+  console.log(`Aris Mac Cleaner v${VERSION}`);
+  process.exit(0);
+}
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+${gradient.pastel.multiline(ASCII_LOGO)}
+
+Usage:
+  aris-mac-cleaner              Start interactive menu
+  aris-mac-cleaner -q           Quick clean without menu
+  aris-mac-cleaner --dry-run    Preview mode (nothing deleted)
+  aris-mac-cleaner --secure     Secure delete (overwrite before delete)
+  aris-mac-cleaner -v           Show version
+  aris-mac-cleaner -h           Show this help
+
+Config directory: ~/.aris-mac-cleaner/
+
+Premium Features:
+  - Animated logo with gradient colors
+  - Progress bars and spinners
+  - Auto-update checker
+  - Backup before clean
+  - Cleanup history with ASCII charts
+  - Disk analyzer with visual tree
+  - Smart recommendations
+  - HTML report export
+  - Benchmark mode
+  - Privacy sweep
+  - Memory optimizer
+  - Scheduled cleanups (launchd)
+  - Sound notifications
+  - Dry-run and secure delete modes
+`);
+  process.exit(0);
+}
+
+if (args.includes('--quick') || args.includes('-q')) {
+  (async () => {
+    getSystemStats();
+    await quickClean();
+  })();
+} else {
+  // Show animated logo and start menu
+  (async () => {
+    await animateLogo();
+    getSystemStats();
+    mainMenu();
+  })();
+}