@tukuyomil032/broom 1.0.0

package/dist/commands/watch.js

@@ -0,0 +1,258 @@
+/**
+ * Watch command - Monitor directory sizes
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { expandPath, formatSize, exists } from '../utils/fs.js';
+import { printHeader, separator, success, error, warning } from '../ui/output.js';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const WATCH_CONFIG_FILE = expandPath('~/.config/broom/watch.json');
+/**
+ * Parse size threshold
+ */
+function parseThreshold(thresholdStr) {
+    const match = thresholdStr.match(/^(\d+(?:\.\d+)?)(KB|MB|GB|TB)?$/i);
+    if (!match) {
+        throw new Error(`Invalid threshold format: ${thresholdStr}`);
+    }
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 'MB').toUpperCase();
+    switch (unit) {
+        case 'KB':
+            return value * 1024;
+        case 'MB':
+            return value * 1024 * 1024;
+        case 'GB':
+            return value * 1024 * 1024 * 1024;
+        case 'TB':
+            return value * 1024 * 1024 * 1024 * 1024;
+        default:
+            return value * 1024 * 1024; // Default to MB
+    }
+}
+/**
+ * Load watch configuration
+ */
+async function loadWatchConfig() {
+    try {
+        if (exists(WATCH_CONFIG_FILE)) {
+            const content = await readFile(WATCH_CONFIG_FILE, 'utf-8');
+            const data = JSON.parse(content);
+            // Parse dates
+            return data.map((w) => ({
+                ...w,
+                lastNotified: w.lastNotified ? new Date(w.lastNotified) : undefined,
+            }));
+        }
+    }
+    catch {
+        // Return empty array if cannot read
+    }
+    return [];
+}
+/**
+ * Save watch configuration
+ */
+async function saveWatchConfig(watches) {
+    await mkdir(expandPath('~/.config/broom'), { recursive: true });
+    await writeFile(WATCH_CONFIG_FILE, JSON.stringify(watches, null, 2), 'utf-8');
+}
+/**
+ * Get directory size
+ */
+async function getDirectorySize(path) {
+    try {
+        const { stdout } = await execAsync(`du -sk "${path}"`);
+        const size = parseInt(stdout.split('\t')[0]) * 1024;
+        return size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Send macOS notification
+ */
+async function sendNotification(title, message) {
+    try {
+        const script = `display notification "${message}" with title "${title}" sound name "default"`;
+        await execAsync(`osascript -e '${script}'`);
+    }
+    catch {
+        // Notification failed
+    }
+}
+/**
+ * Add watch
+ */
+async function addWatch(options) {
+    if (!options.path) {
+        error('--path is required');
+        return;
+    }
+    if (!options.threshold) {
+        error('--threshold is required (e.g., 5GB)');
+        return;
+    }
+    const path = expandPath(options.path);
+    if (!exists(path)) {
+        error(`Path does not exist: ${path}`);
+        return;
+    }
+    const threshold = parseThreshold(options.threshold);
+    const watches = await loadWatchConfig();
+    // Check if already watching
+    if (watches.some((w) => w.path === path)) {
+        warning(`Already watching: ${path}`);
+        return;
+    }
+    watches.push({
+        path,
+        threshold,
+        notify: options.notify ?? true,
+        autoClean: options.autoClean ?? false,
+    });
+    await saveWatchConfig(watches);
+    success(`Added watch: ${path}`);
+    console.log(`  Threshold: ${formatSize(threshold)}`);
+    console.log(`  Notify: ${options.notify ?? true}`);
+    console.log(`  Auto-clean: ${options.autoClean ?? false}`);
+}
+/**
+ * Remove watch
+ */
+async function removeWatch(pathToRemove) {
+    const expandedPath = expandPath(pathToRemove);
+    const watches = await loadWatchConfig();
+    const index = watches.findIndex((w) => w.path === expandedPath);
+    if (index === -1) {
+        error(`Not watching: ${expandedPath}`);
+        return;
+    }
+    watches.splice(index, 1);
+    await saveWatchConfig(watches);
+    success(`Removed watch: ${expandedPath}`);
+}
+/**
+ * List watches
+ */
+async function listWatches() {
+    printHeader('👀 Directory Watches');
+    const watches = await loadWatchConfig();
+    if (watches.length === 0) {
+        warning('No watches configured');
+        console.log();
+        console.log(chalk.dim('Use "broom watch --add --path <path> --threshold 5GB" to add a watch'));
+        return;
+    }
+    console.log();
+    for (const watch of watches) {
+        console.log(chalk.bold(`📁 ${watch.path}`));
+        console.log(`  Threshold: ${chalk.cyan(formatSize(watch.threshold))}`);
+        console.log(`  Notify: ${watch.notify ? chalk.green('Yes') : chalk.red('No')}`);
+        console.log(`  Auto-clean: ${watch.autoClean ? chalk.green('Yes') : chalk.red('No')}`);
+        if (watch.lastNotified) {
+            console.log(`  Last notified: ${chalk.dim(watch.lastNotified.toLocaleString())}`);
+        }
+        console.log();
+    }
+    separator();
+    console.log();
+    console.log(chalk.dim('Use "broom watch --check" to check all watches'));
+    console.log(chalk.dim('Use "broom watch --remove <path>" to remove a watch'));
+}
+/**
+ * Check watches
+ */
+async function checkWatches() {
+    printHeader('👀 Checking Watches');
+    const watches = await loadWatchConfig();
+    if (watches.length === 0) {
+        warning('No watches configured');
+        return;
+    }
+    console.log();
+    let needsSave = false;
+    for (const watch of watches) {
+        const size = await getDirectorySize(watch.path);
+        const percentage = (size / watch.threshold) * 100;
+        const exceeded = size > watch.threshold;
+        console.log(chalk.bold(`📁 ${watch.path}`));
+        console.log(`  Current size: ${chalk.cyan(formatSize(size))}`);
+        console.log(`  Threshold: ${formatSize(watch.threshold)}`);
+        if (exceeded) {
+            console.log(chalk.red(`  ⚠️  EXCEEDED (${percentage.toFixed(1)}%)`));
+            // Send notification if enabled
+            if (watch.notify) {
+                const now = new Date();
+                const hoursSinceLastNotif = watch.lastNotified
+                    ? (now.getTime() - watch.lastNotified.getTime()) / (1000 * 60 * 60)
+                    : 24;
+                // Only notify once per 6 hours
+                if (hoursSinceLastNotif >= 6) {
+                    await sendNotification('Broom Alert', `${watch.path} exceeded ${formatSize(watch.threshold)}`);
+                    watch.lastNotified = now;
+                    needsSave = true;
+                    console.log(chalk.dim('  📬 Notification sent'));
+                }
+            }
+            // Auto-clean if enabled
+            if (watch.autoClean) {
+                console.log(chalk.dim('  🧹 Auto-clean triggered'));
+                // TODO: Trigger cleanup for this path
+            }
+        }
+        else {
+            console.log(chalk.green(`  ✓ OK (${percentage.toFixed(1)}%)`));
+        }
+        console.log();
+    }
+    if (needsSave) {
+        await saveWatchConfig(watches);
+    }
+    separator();
+}
+/**
+ * Execute watch command
+ */
+export async function watchCommand(options) {
+    if (options.add) {
+        await addWatch(options);
+        return;
+    }
+    if (options.remove) {
+        await removeWatch(options.remove);
+        return;
+    }
+    if (options.check) {
+        await checkWatches();
+        return;
+    }
+    if (options.list || Object.keys(options).length === 0) {
+        await listWatches();
+        return;
+    }
+}
+/**
+ * Create watch command
+ */
+export function createWatchCommand() {
+    const cmd = new Command('watch')
+        .description('Monitor directory sizes')
+        .option('-a, --add', 'Add a new watch')
+        .option('-r, --remove <path>', 'Remove a watch')
+        .option('-l, --list', 'List all watches')
+        .option('-c, --check', 'Check all watches now')
+        .option('-p, --path <path>', 'Path to watch')
+        .option('-t, --threshold <size>', 'Size threshold (e.g., 5GB)')
+        .option('-n, --notify', 'Enable notifications (default: true)')
+        .option('--auto-clean', 'Automatically clean when threshold exceeded')
+        .action(async (options) => {
+        await watchCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/index.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * broom - macOS Disk Cleanup CLI
+ *
+ * A TypeScript rewrite of mole (https://github.com/tw93/Mole)
+ * with modern features and interactive interface.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createCleanCommand, createUninstallCommand, createOptimizeCommand, createAnalyzeCommand, createStatusCommand, createPurgeCommand, createInstallerCommand, createTouchIdCommand, createCompletionCommand, createUpdateCommand, createRemoveCommand, createConfigCommand, createDoctorCommand, createBackupCommand, createRestoreCommand, createDuplicatesCommand, createScheduleCommand, createWatchCommand, createReportsCommand, createHelpCommand, setCommandsList, } from './commands/index.js';
+import { enableDebug, debug } from './utils/debug.js';
+import { getGlobalOptionsTable } from './utils/help.js';
+const VERSION = '1.0.0';
+// ASCII art logo
+const logo = chalk.cyan(`
+  ██████╗ ██████╗  ██████╗  ██████╗ ███╗   ███╗
+  ██╔══██╗██╔══██╗██╔═══██╗██╔═══██╗████╗ ████║
+  ██████╔╝██████╔╝██║   ██║██║   ██║██╔████╔██║
+  ██╔══██╗██╔══██╗██║   ██║██║   ██║██║╚██╔╝██║
+  ██████╔╝██║  ██║╚██████╔╝╚██████╔╝██║ ╚═╝ ██║
+  ╚═════╝ ╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝     ╚═╝
+`);
+const description = `
+${logo}
+${chalk.bold('🧹 macOS Disk Cleanup CLI')}
+
+Clean up your Mac with ease. Remove caches, logs, trash,
+browser data, dev artifacts, and more.
+
+${chalk.bold('Commands:')}
+  clean       Scan and clean up disk space
+  uninstall   Remove apps and their leftovers
+  optimize    System maintenance and optimization
+  analyze     Analyze disk space usage
+  status      Show system status and resource usage
+  purge       Clean project-specific build artifacts
+  installer   Find and remove installer files
+  touchid     Configure Touch ID for sudo
+  completion  Generate shell completion scripts
+  update      Self-update broom to the latest version
+  remove      Uninstall broom from the system
+  config      Manage broom configuration
+  doctor      Run system health diagnostics
+  backup      Manage file backups
+  restore     Restore files from backup
+  duplicates  Find and remove duplicate files
+  schedule    Schedule automated cleanups
+  watch       Monitor directory sizes
+  reports     Manage cleanup reports
+
+${chalk.bold('Examples:')}
+  ${chalk.dim('$')} broom clean              Interactive cleanup
+  ${chalk.dim('$')} broom clean --dry-run    Preview what would be cleaned
+  ${chalk.dim('$')} broom clean --all        Clean all categories
+  ${chalk.dim('$')} broom uninstall          Remove an app completely
+  ${chalk.dim('$')} broom optimize           Run system optimization tasks
+  ${chalk.dim('$')} broom analyze            See what's using disk space
+  ${chalk.dim('$')} broom status --watch     Live system monitoring
+  ${chalk.dim('$')} broom purge              Clean project artifacts
+
+${getGlobalOptionsTable()}
+`;
+// Create program
+const program = new Command();
+program
+    .name('broom')
+    .version(VERSION, '-v, --version', 'Output the current version')
+    .description(description)
+    .option('--debug', 'Enable debug mode with detailed logs')
+    .helpOption('-h, --help', 'Display help for command')
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.debug) {
+        enableDebug();
+        debug('Debug mode enabled');
+        debug(`Version: ${VERSION}`);
+        debug(`Node: ${process.version}`);
+        debug(`Platform: ${process.platform} ${process.arch}`);
+        debug(`Args: ${process.argv.slice(2).join(' ')}`);
+    }
+});
+// Register commands
+const helpCommand = createHelpCommand();
+program.addCommand(helpCommand);
+program.addCommand(createCleanCommand());
+program.addCommand(createUninstallCommand());
+program.addCommand(createOptimizeCommand());
+program.addCommand(createAnalyzeCommand());
+program.addCommand(createStatusCommand());
+program.addCommand(createPurgeCommand());
+program.addCommand(createInstallerCommand());
+program.addCommand(createTouchIdCommand());
+program.addCommand(createCompletionCommand());
+program.addCommand(createUpdateCommand());
+program.addCommand(createRemoveCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createDoctorCommand());
+program.addCommand(createBackupCommand());
+program.addCommand(createRestoreCommand());
+program.addCommand(createDuplicatesCommand());
+program.addCommand(createScheduleCommand());
+program.addCommand(createWatchCommand());
+program.addCommand(createReportsCommand());
+// Set the commands list for the help command
+setCommandsList([
+    createCleanCommand(),
+    createUninstallCommand(),
+    createOptimizeCommand(),
+    createAnalyzeCommand(),
+    createStatusCommand(),
+    createPurgeCommand(),
+    createInstallerCommand(),
+    createTouchIdCommand(),
+    createCompletionCommand(),
+    createUpdateCommand(),
+    createRemoveCommand(),
+    createConfigCommand(),
+    createDoctorCommand(),
+    createBackupCommand(),
+    createRestoreCommand(),
+    createDuplicatesCommand(),
+    createScheduleCommand(),
+    createWatchCommand(),
+    createReportsCommand(),
+]);
+// Parse arguments
+program.parse(process.argv);
+// Show help if no command provided (only if no subcommand was executed)
+if (process.argv.length === 2) {
+    console.log(description);
+}

package/dist/scanners/base.js

@@ -0,0 +1,21 @@
+import { removeItems } from '../utils/fs.js';
+export class BaseScanner {
+    async clean(items, dryRun = false) {
+        const result = await removeItems(items, dryRun);
+        return {
+            category: this.category,
+            cleanedItems: result.success,
+            freedSpace: result.freedSpace,
+            errors: result.failed > 0 ? [`Failed to remove ${result.failed} items`] : [],
+        };
+    }
+    createResult(items, error) {
+        const totalSize = items.reduce((sum, item) => sum + item.size, 0);
+        return {
+            category: this.category,
+            items,
+            totalSize,
+            error,
+        };
+    }
+}

package/dist/scanners/browser-cache.js

@@ -0,0 +1,111 @@
+/**
+ * Browser cache scanner
+ */
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { BaseScanner } from './base.js';
+import { paths } from '../utils/paths.js';
+import { exists, getSize } from '../utils/fs.js';
+export class BrowserCacheScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'browser-cache',
+            name: 'Browser Cache',
+            group: 'Browsers',
+            description: 'Cache from Chrome, Safari, Firefox, Edge, Brave, Arc',
+            safetyLevel: 'safe',
+        };
+        this.browsers = [
+            {
+                name: 'Chrome',
+                paths: [paths.browserCache.chrome, paths.browserCache.chromeProfile],
+            },
+            {
+                name: 'Safari',
+                paths: [paths.browserCache.safari],
+            },
+            {
+                name: 'Firefox',
+                paths: [paths.browserCache.firefox],
+            },
+            {
+                name: 'Edge',
+                paths: [paths.browserCache.edge, paths.browserCache.edgeProfile],
+            },
+            {
+                name: 'Brave',
+                paths: [paths.browserCache.brave, paths.browserCache.braveProfile],
+            },
+            {
+                name: 'Arc',
+                paths: [paths.browserCache.arc, paths.browserCache.arcProfile],
+            },
+        ];
+    }
+    async scan(_options) {
+        const items = [];
+        for (const browser of this.browsers) {
+            for (const browserPath of browser.paths) {
+                try {
+                    if (!exists(browserPath)) {
+                        continue;
+                    }
+                    // Check if it's a directory that contains cache
+                    const stats = await stat(browserPath);
+                    if (stats.isDirectory()) {
+                        const entries = await readdir(browserPath);
+                        // Look for cache-related directories
+                        const cachePatterns = ['Cache', 'cache', 'GPUCache', 'ShaderCache', 'Code Cache'];
+                        for (const entry of entries) {
+                            if (cachePatterns.some((p) => entry.includes(p)) || entry === 'Cache') {
+                                const entryPath = join(browserPath, entry);
+                                const entryStats = await stat(entryPath);
+                                const size = await getSize(entryPath);
+                                if (size > 0) {
+                                    items.push({
+                                        path: entryPath,
+                                        size,
+                                        name: `${browser.name} - ${entry}`,
+                                        isDirectory: entryStats.isDirectory(),
+                                        modifiedAt: entryStats.mtime,
+                                    });
+                                }
+                            }
+                        }
+                        // Also add the main cache directory if it's not too nested
+                        if (browserPath.includes('Cache')) {
+                            const size = await getSize(browserPath);
+                            if (size > 0) {
+                                items.push({
+                                    path: browserPath,
+                                    size,
+                                    name: `${browser.name} Cache`,
+                                    isDirectory: true,
+                                    modifiedAt: stats.mtime,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        // Remove duplicates (prefer larger paths)
+        const uniqueItems = this.deduplicateItems(items);
+        uniqueItems.sort((a, b) => b.size - a.size);
+        return this.createResult(uniqueItems);
+    }
+    deduplicateItems(items) {
+        const seen = new Map();
+        for (const item of items) {
+            const existing = seen.get(item.path);
+            if (!existing || item.size > existing.size) {
+                seen.set(item.path, item);
+            }
+        }
+        return Array.from(seen.values());
+    }
+}

package/dist/scanners/dev-cache.js

@@ -0,0 +1,64 @@
+/**
+ * Development cache scanner
+ */
+import { stat } from 'fs/promises';
+import { BaseScanner } from './base.js';
+import { paths } from '../utils/paths.js';
+import { exists, getSize } from '../utils/fs.js';
+export class DevCacheScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'dev-cache',
+            name: 'Development Cache',
+            group: 'Development',
+            description: 'Package manager caches (npm, yarn, pip, cargo, etc.)',
+            safetyLevel: 'moderate',
+            safetyNote: 'May require reinstalling packages',
+        };
+        this.devTools = [
+            { name: 'npm cache', path: paths.devCache.npm, safeToClean: true },
+            { name: 'npm _cacache', path: paths.devCache.npmCache, safeToClean: true },
+            { name: 'Yarn cache', path: paths.devCache.yarn, safeToClean: true },
+            { name: 'pnpm store', path: paths.devCache.pnpm, safeToClean: true },
+            { name: 'Bun cache', path: paths.devCache.bun, safeToClean: true },
+            { name: 'pip cache', path: paths.devCache.pip, safeToClean: true },
+            { name: 'pip cache (alt)', path: paths.devCache.pipCache, safeToClean: true },
+            { name: 'Cargo cache', path: paths.devCache.cargo, safeToClean: true },
+            { name: 'Rustup downloads', path: paths.devCache.rustup, safeToClean: true },
+            { name: 'Go mod cache', path: paths.devCache.go, safeToClean: true },
+            { name: 'Gradle caches', path: paths.devCache.gradle, safeToClean: true },
+            { name: 'Maven repository', path: paths.devCache.maven, safeToClean: false },
+            { name: 'CocoaPods cache', path: paths.devCache.cocoapods, safeToClean: true },
+            { name: 'Carthage cache', path: paths.devCache.carthage, safeToClean: true },
+            { name: 'Composer cache', path: paths.devCache.composer, safeToClean: true },
+        ];
+    }
+    async scan(_options) {
+        const items = [];
+        for (const tool of this.devTools) {
+            try {
+                if (!exists(tool.path)) {
+                    continue;
+                }
+                const stats = await stat(tool.path);
+                const size = await getSize(tool.path);
+                if (size > 1024 * 1024) {
+                    // Only include if > 1MB
+                    items.push({
+                        path: tool.path,
+                        size,
+                        name: tool.name,
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                    });
+                }
+            }
+            catch {
+                // Skip if cannot access
+            }
+        }
+        items.sort((a, b) => b.size - a.size);
+        return this.createResult(items);
+    }
+}

package/dist/scanners/docker.js

@@ -0,0 +1,96 @@
+/**
+ * Docker cache scanner
+ */
+import { stat } from 'fs/promises';
+import { BaseScanner } from './base.js';
+import { paths } from '../utils/paths.js';
+import { exists, getSize } from '../utils/fs.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class DockerScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'docker',
+            name: 'Docker Data',
+            group: 'Development',
+            description: 'Docker images, containers, and volumes',
+            safetyLevel: 'risky',
+            safetyNote: 'Will remove all unused Docker data',
+        };
+    }
+    async scan(_options) {
+        const items = [];
+        try {
+            // Check Docker data directory
+            if (exists(paths.docker.data)) {
+                const stats = await stat(paths.docker.data);
+                const size = await getSize(paths.docker.data);
+                if (size > 0) {
+                    items.push({
+                        path: paths.docker.data,
+                        size,
+                        name: 'Docker Data',
+                        isDirectory: true,
+                        modifiedAt: stats.mtime,
+                    });
+                }
+            }
+            // Check VM disk specifically
+            if (exists(paths.docker.vmDisk)) {
+                const stats = await stat(paths.docker.vmDisk);
+                const size = await getSize(paths.docker.vmDisk);
+                if (size > 0) {
+                    items.push({
+                        path: paths.docker.vmDisk,
+                        size,
+                        name: 'Docker VM Disk',
+                        isDirectory: true,
+                        modifiedAt: stats.mtime,
+                    });
+                }
+            }
+        }
+        catch {
+            // Docker might not be installed
+        }
+        items.sort((a, b) => b.size - a.size);
+        // Deduplicate (vmDisk is inside data)
+        const uniqueItems = items.filter((item, index, self) => {
+            return !self.some((other, otherIndex) => otherIndex !== index && item.path.startsWith(other.path + '/'));
+        });
+        return this.createResult(uniqueItems);
+    }
+    async clean(items, dryRun = false) {
+        if (dryRun) {
+            const totalSize = items.reduce((sum, item) => sum + item.size, 0);
+            return {
+                category: this.category,
+                cleanedItems: items.length,
+                freedSpace: totalSize,
+                errors: [],
+            };
+        }
+        try {
+            // Try using docker system prune
+            await execAsync('docker system prune -af --volumes 2>/dev/null || true');
+            const totalSize = items.reduce((sum, item) => sum + item.size, 0);
+            return {
+                category: this.category,
+                cleanedItems: items.length,
+                freedSpace: totalSize,
+                errors: [],
+            };
+        }
+        catch {
+            // Docker not running or not installed
+            return {
+                category: this.category,
+                cleanedItems: 0,
+                freedSpace: 0,
+                errors: ['Docker is not running or not installed'],
+            };
+        }
+    }
+}