@tukuyomil032/broom 1.0.0

package/dist/commands/installer.js

@@ -0,0 +1,266 @@
+/**
+ * Installer command - Find and remove installer files
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { readdir, stat, rm } from 'fs/promises';
+import { join, basename, extname } from 'path';
+import fg from 'fast-glob';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { exists, getSize, formatSize, expandPath } from '../utils/fs.js';
+import { printHeader, success, warning, error, info, separator, createSpinner, succeedSpinner, failSpinner, } from '../ui/output.js';
+import { confirmAction, selectFiles } from '../ui/prompts.js';
+/**
+ * Installer file extensions
+ */
+const INSTALLER_EXTENSIONS = ['.dmg', '.pkg', '.zip', '.app', '.tar.gz', '.tgz'];
+/**
+ * Directories to search for installers
+ */
+const SEARCH_DIRS = [
+    '~/Downloads',
+    '~/Desktop',
+    '~/Library/Caches/Homebrew/downloads',
+    '~/Library/Mobile Documents/com~apple~CloudDocs/Downloads',
+    '~/Library/Application Support/Steam/steamapps',
+];
+/**
+ * Get source label from path
+ */
+function getSourceLabel(filePath) {
+    const home = expandPath('~');
+    const path = filePath.toLowerCase();
+    if (path.includes('/downloads')) {
+        return 'Downloads';
+    }
+    if (path.includes('/desktop')) {
+        return 'Desktop';
+    }
+    if (path.includes('/homebrew')) {
+        return 'Homebrew';
+    }
+    if (path.includes('/clouddocs') || path.includes('/icloud')) {
+        return 'iCloud';
+    }
+    if (path.includes('/steam')) {
+        return 'Steam';
+    }
+    if (path.includes('/mail')) {
+        return 'Mail';
+    }
+    return 'Other';
+}
+/**
+ * Check if file is an installer
+ */
+function isInstaller(filename) {
+    const ext = extname(filename).toLowerCase();
+    const name = filename.toLowerCase();
+    // Check extension
+    if (INSTALLER_EXTENSIONS.includes(ext)) {
+        return true;
+    }
+    // Check for .tar.gz
+    if (name.endsWith('.tar.gz') || name.endsWith('.tgz')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Scan for installer files
+ */
+async function scanInstallers() {
+    const installers = [];
+    for (const searchDir of SEARCH_DIRS) {
+        const dir = expandPath(searchDir);
+        if (!exists(dir)) {
+            continue;
+        }
+        try {
+            const entries = await readdir(dir);
+            for (const entry of entries) {
+                if (!isInstaller(entry)) {
+                    continue;
+                }
+                const filePath = join(dir, entry);
+                try {
+                    const stats = await stat(filePath);
+                    const size = stats.isDirectory() ? await getSize(filePath) : stats.size;
+                    // Only include files larger than 10MB
+                    if (size < 10 * 1024 * 1024) {
+                        continue;
+                    }
+                    installers.push({
+                        path: filePath,
+                        name: entry,
+                        size,
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                        source: getSourceLabel(filePath),
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        catch {
+            // Skip if cannot access directory
+        }
+    }
+    // Also search recursively in Downloads for nested installers
+    const downloadsDir = expandPath('~/Downloads');
+    if (exists(downloadsDir)) {
+        try {
+            const patterns = INSTALLER_EXTENSIONS.map((ext) => `**/*${ext}`);
+            const matches = await fg(patterns, {
+                cwd: downloadsDir,
+                absolute: true,
+                deep: 3, // Max depth
+                ignore: ['**/node_modules/**'],
+            });
+            for (const match of matches) {
+                // Skip if already added
+                if (installers.some((i) => i.path === match)) {
+                    continue;
+                }
+                try {
+                    const stats = await stat(match);
+                    const size = stats.isDirectory() ? await getSize(match) : stats.size;
+                    if (size < 10 * 1024 * 1024) {
+                        continue;
+                    }
+                    installers.push({
+                        path: match,
+                        name: basename(match),
+                        size,
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                        source: 'Downloads',
+                    });
+                }
+                catch {
+                    // Skip
+                }
+            }
+        }
+        catch {
+            // Skip
+        }
+    }
+    // Sort by size descending
+    installers.sort((a, b) => b.size - a.size);
+    return installers;
+}
+/**
+ * Execute installer command
+ */
+export async function installerCommand(options) {
+    const isDryRun = options.dryRun || false;
+    printHeader(isDryRun ? '💿 Installer Files (Dry Run)' : '💿 Installer Files');
+    // Scan for installers
+    const spinner = createSpinner('Scanning for installer files...');
+    const installers = await scanInstallers();
+    succeedSpinner(spinner, `Found ${installers.length} installer files`);
+    if (installers.length === 0) {
+        console.log();
+        success('No installer files found!');
+        return;
+    }
+    // Calculate total size
+    const totalSize = installers.reduce((sum, i) => sum + i.size, 0);
+    // Show found installers
+    console.log();
+    console.log(chalk.bold(`Found ${installers.length} installer files (${formatSize(totalSize)}):`));
+    console.log();
+    for (const installer of installers.slice(0, 15)) {
+        const sizeStr = formatSize(installer.size).padStart(10);
+        const sourceStr = chalk.dim(`| ${installer.source}`);
+        console.log(`  ${chalk.cyan('●')} ${installer.name.slice(0, 30).padEnd(32)} ${chalk.yellow(sizeStr)} ${sourceStr}`);
+    }
+    if (installers.length > 15) {
+        console.log(chalk.dim(`  ... and ${installers.length - 15} more`));
+    }
+    // Select files to remove
+    console.log();
+    let selectedInstallers;
+    if (options.yes) {
+        selectedInstallers = installers;
+    }
+    else {
+        info('Select installers to remove:');
+        selectedInstallers = (await selectFiles(installers));
+    }
+    if (selectedInstallers.length === 0) {
+        warning('No installers selected');
+        return;
+    }
+    const selectedSize = selectedInstallers.reduce((sum, i) => sum + i.size, 0);
+    // Confirm
+    if (!options.yes) {
+        console.log();
+        const confirmed = await confirmAction(`${isDryRun ? 'Simulate removing' : 'Remove'} ${selectedInstallers.length} installers (${formatSize(selectedSize)})?`, false);
+        if (!confirmed) {
+            warning('Operation cancelled');
+            return;
+        }
+    }
+    // Execute removal
+    console.log();
+    const removeSpinner = createSpinner(isDryRun ? 'Simulating removal...' : 'Removing installers...');
+    let removedCount = 0;
+    let removedSize = 0;
+    const errors = [];
+    for (const installer of selectedInstallers) {
+        if (!isDryRun) {
+            try {
+                await rm(installer.path, { recursive: true, force: true });
+                removedCount++;
+                removedSize += installer.size;
+            }
+            catch (err) {
+                errors.push(`${installer.name}: ${err.message}`);
+            }
+        }
+        else {
+            removedCount++;
+            removedSize += installer.size;
+        }
+    }
+    if (errors.length === 0) {
+        succeedSpinner(removeSpinner, isDryRun ? 'Simulation complete' : 'Removal complete');
+    }
+    else {
+        failSpinner(removeSpinner, 'Completed with errors');
+    }
+    // Summary
+    console.log();
+    separator('═');
+    console.log(chalk.bold(isDryRun ? 'Dry Run Complete' : 'Removal Complete'));
+    separator('─');
+    console.log(`  Installers ${isDryRun ? 'would be ' : ''}removed: ${chalk.green(removedCount)}`);
+    console.log(`  Space ${isDryRun ? 'would be ' : ''}freed: ${chalk.green(formatSize(removedSize))}`);
+    separator('═');
+    if (errors.length > 0) {
+        console.log();
+        console.log(chalk.bold.red('Errors:'));
+        errors.forEach((err) => error(err));
+    }
+    if (isDryRun) {
+        console.log();
+        info('This was a dry run. No files were deleted.');
+    }
+}
+/**
+ * Create installer command
+ */
+export function createInstallerCommand() {
+    const cmd = new Command('installer')
+        .description('Find and remove installer files (dmg, pkg, zip)')
+        .option('-n, --dry-run', 'Preview only, no deletions')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (options) => {
+        await installerCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/optimize.js

@@ -0,0 +1,270 @@
+/**
+ * Optimize command - System maintenance and optimization
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { printHeader, warning, info, separator, createSpinner, succeedSpinner, failSpinner, } from '../ui/output.js';
+import { confirmAction, selectItems } from '../ui/prompts.js';
+import { debug, debugSection, debugObj } from '../utils/debug.js';
+const execAsync = promisify(exec);
+/**
+ * Available optimization tasks
+ */
+const tasks = [
+    {
+        id: 'flush-dns',
+        name: 'Flush DNS Cache',
+        description: 'Clear DNS resolver cache',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo dscacheutil -flushcache');
+            await execAsync('sudo killall -HUP mDNSResponder');
+            return 'DNS cache flushed';
+        },
+    },
+    {
+        id: 'rebuild-spotlight',
+        name: 'Rebuild Spotlight Index',
+        description: 'Rebuild the Spotlight search index (may take a while)',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo mdutil -E /');
+            return 'Spotlight reindexing started';
+        },
+    },
+    {
+        id: 'rebuild-launch-services',
+        name: 'Rebuild Launch Services',
+        description: 'Rebuild the Launch Services database',
+        requiresSudo: false,
+        action: async () => {
+            await execAsync('/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -kill -r -domain local -domain system -domain user');
+            return 'Launch Services database rebuilt';
+        },
+    },
+    {
+        id: 'purge-memory',
+        name: 'Purge Memory',
+        description: 'Release inactive memory',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo purge');
+            return 'Memory purged';
+        },
+    },
+    {
+        id: 'verify-disk',
+        name: 'Verify Disk',
+        description: 'Verify the boot disk',
+        requiresSudo: false,
+        action: async () => {
+            const { stdout } = await execAsync('diskutil verifyVolume /');
+            return stdout.trim() || 'Disk verification completed';
+        },
+    },
+    {
+        id: 'clear-font-cache',
+        name: 'Clear Font Cache',
+        description: 'Clear system font caches',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo atsutil databases -remove');
+            return 'Font caches cleared (restart may be required)';
+        },
+    },
+    {
+        id: 'rebuild-mail-index',
+        name: 'Rebuild Mail Index',
+        description: 'Rebuild Mail.app envelope index',
+        requiresSudo: false,
+        action: async () => {
+            const mailEnvelope = '~/Library/Mail/V*/MailData/Envelope Index';
+            await execAsync(`rm -rf ${mailEnvelope} 2>/dev/null || true`);
+            return 'Mail index will be rebuilt on next launch';
+        },
+    },
+    {
+        id: 'clear-quicklook',
+        name: 'Clear QuickLook Cache',
+        description: 'Reset QuickLook server',
+        requiresSudo: false,
+        action: async () => {
+            await execAsync('qlmanage -r cache');
+            await execAsync('qlmanage -r');
+            return 'QuickLook cache cleared';
+        },
+    },
+    {
+        id: 'reset-bluetooth',
+        name: 'Reset Bluetooth Module',
+        description: 'Reset the Bluetooth controller',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo pkill -9 bluetoothd || true');
+            return 'Bluetooth module reset';
+        },
+    },
+    {
+        id: 'flush-network',
+        name: 'Flush Network Settings',
+        description: 'Reset network interfaces',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo ifconfig en0 down && sudo ifconfig en0 up');
+            return 'Network interface reset';
+        },
+    },
+    {
+        id: 'clear-asl-logs',
+        name: 'Clear ASL Logs',
+        description: 'Clear Apple System Logs',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo rm -rf /private/var/log/asl/*.asl');
+            return 'ASL logs cleared';
+        },
+    },
+    {
+        id: 'enable-trim',
+        name: 'Enable TRIM (SSD)',
+        description: 'Enable TRIM for non-Apple SSDs',
+        requiresSudo: true,
+        action: async () => {
+            await execAsync('sudo trimforce enable');
+            return 'TRIM enabled';
+        },
+    },
+];
+/**
+ * Execute optimize command
+ */
+export async function optimizeCommand(options) {
+    const isDryRun = options.dryRun || false;
+    debugSection('Optimize Command');
+    debugObj('Options', options);
+    debug(`Available tasks: ${tasks.length}`);
+    printHeader(isDryRun ? '⚡ System Optimization (Dry Run)' : '⚡ System Optimization');
+    // Show available tasks
+    console.log(chalk.bold('Available optimization tasks:'));
+    console.log();
+    tasks.forEach((task, index) => {
+        const sudo = task.requiresSudo ? chalk.yellow('[sudo]') : '';
+        console.log(`  ${chalk.cyan(`${index + 1}.`)} ${chalk.bold(task.name)} ${sudo}`);
+        console.log(`     ${chalk.dim(task.description)}`);
+    });
+    console.log();
+    // Select tasks
+    let selectedTasks;
+    if (options.all) {
+        selectedTasks = tasks;
+        info(`Running all ${tasks.length} optimization tasks`);
+    }
+    else {
+        const taskChoices = tasks.map((task) => ({
+            name: `${task.name}${task.requiresSudo ? ' [sudo]' : ''}`,
+            value: task.id,
+            description: task.description,
+        }));
+        const selectedIds = await selectItems('Select optimization tasks to run:', taskChoices);
+        if (selectedIds.length === 0) {
+            warning('No tasks selected');
+            return;
+        }
+        selectedTasks = tasks.filter((t) => selectedIds.includes(t.id));
+    }
+    // Check for sudo tasks
+    const sudoTasks = selectedTasks.filter((t) => t.requiresSudo);
+    if (sudoTasks.length > 0 && !isDryRun) {
+        console.log();
+        warning(`${sudoTasks.length} task(s) require administrator privileges`);
+        if (!options.yes) {
+            const confirmed = await confirmAction('Continue with sudo tasks?', true);
+            if (!confirmed) {
+                // Filter out sudo tasks
+                selectedTasks = selectedTasks.filter((t) => !t.requiresSudo);
+                if (selectedTasks.length === 0) {
+                    warning('No tasks remaining');
+                    return;
+                }
+            }
+        }
+    }
+    // Confirm execution
+    if (!options.yes && !isDryRun) {
+        console.log();
+        const confirmed = await confirmAction(`Run ${selectedTasks.length} optimization task(s)?`, true);
+        if (!confirmed) {
+            warning('Optimization cancelled');
+            return;
+        }
+    }
+    // Execute tasks
+    console.log();
+    separator();
+    let successCount = 0;
+    let failCount = 0;
+    const results = [];
+    for (const task of selectedTasks) {
+        debug(`Executing task: ${task.id} - ${task.name}`);
+        debug(`Requires sudo: ${task.requiresSudo}`);
+        const spinner = createSpinner(`${task.name}...`);
+        if (isDryRun) {
+            debug(`Task ${task.id} skipped (dry run)`);
+            succeedSpinner(spinner, `${task.name} ${chalk.dim('(dry run)')}`);
+            results.push({ task, success: true, message: 'Dry run - skipped' });
+            successCount++;
+            continue;
+        }
+        try {
+            const message = await task.action();
+            debug(`Task ${task.id} completed: ${message}`);
+            succeedSpinner(spinner, `${task.name}: ${chalk.green(message)}`);
+            results.push({ task, success: true, message });
+            successCount++;
+        }
+        catch (err) {
+            const errorMsg = err.message || 'Unknown error';
+            debug(`Task ${task.id} failed: ${errorMsg}`);
+            failSpinner(spinner, `${task.name}: ${chalk.red(errorMsg)}`);
+            results.push({ task, success: false, message: errorMsg });
+            failCount++;
+        }
+    }
+    // Print summary
+    console.log();
+    separator();
+    console.log();
+    console.log(chalk.bold('Optimization Summary'));
+    console.log();
+    console.log(`  ${chalk.green('✓')} Successful: ${chalk.green(successCount)}`);
+    if (failCount > 0) {
+        console.log(`  ${chalk.red('✗')} Failed: ${chalk.red(failCount)}`);
+    }
+    if (isDryRun) {
+        console.log();
+        info('This was a dry run. No changes were made.');
+    }
+    // Show recommendations
+    console.log();
+    console.log(chalk.bold('💡 Recommendations:'));
+    console.log(chalk.dim('  - Run optimization monthly for best performance'));
+    console.log(chalk.dim('  - Some changes may require a restart to take effect'));
+    console.log(chalk.dim('  - Use "broom clean" to free up disk space'));
+}
+/**
+ * Create optimize command
+ */
+export function createOptimizeCommand() {
+    const cmd = new Command('optimize')
+        .description('System maintenance and optimization')
+        .option('-n, --dry-run', 'Preview only, no changes')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .option('-a, --all', 'Run all optimization tasks')
+        .action(async (options) => {
+        await optimizeCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}