@tukuyomil032/broom 1.0.0

package/dist/scanners/downloads.js

@@ -0,0 +1,66 @@
+/**
+ * Downloads 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, isExcludedPath } from '../utils/fs.js';
+export class DownloadsScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'downloads',
+            name: 'Old Downloads',
+            group: 'Storage',
+            description: 'Files in Downloads folder older than 30 days',
+            safetyLevel: 'risky',
+            safetyNote: 'Review files before deleting',
+        };
+    }
+    async scan(options) {
+        const items = [];
+        const daysOld = options?.daysOld ?? 30;
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+        try {
+            if (!exists(paths.downloads)) {
+                return this.createResult([]);
+            }
+            const entries = await readdir(paths.downloads);
+            for (const entry of entries) {
+                // Skip hidden files and .localized
+                if (entry.startsWith('.')) {
+                    continue;
+                }
+                const entryPath = join(paths.downloads, entry);
+                // Skip excluded paths (iCloud Drive, etc.)
+                if (isExcludedPath(entryPath)) {
+                    continue;
+                }
+                try {
+                    const stats = await stat(entryPath);
+                    // Only include files older than cutoff
+                    if (stats.mtime < cutoffDate) {
+                        const size = await getSize(entryPath);
+                        items.push({
+                            path: entryPath,
+                            size,
+                            name: entry,
+                            isDirectory: stats.isDirectory(),
+                            modifiedAt: stats.mtime,
+                        });
+                    }
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+            items.sort((a, b) => b.size - a.size);
+            return this.createResult(items);
+        }
+        catch (error) {
+            return this.createResult([], error.message);
+        }
+    }
+}

package/dist/scanners/homebrew.js

@@ -0,0 +1,82 @@
+/**
+ * Homebrew cache scanner
+ */
+import { stat } from 'fs/promises';
+import { BaseScanner } from './base.js';
+import { paths } from '../utils/paths.js';
+import { exists, getSize, removeItems } from '../utils/fs.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class HomebrewScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'homebrew',
+            name: 'Homebrew Cache',
+            group: 'Development',
+            description: 'Homebrew downloads and logs',
+            safetyLevel: 'safe',
+        };
+    }
+    async scan(_options) {
+        const items = [];
+        const homebrewPaths = [paths.homebrew.cache, paths.homebrew.logs, paths.homebrew.downloads];
+        for (const brewPath of homebrewPaths) {
+            try {
+                if (!exists(brewPath)) {
+                    continue;
+                }
+                const stats = await stat(brewPath);
+                const size = await getSize(brewPath);
+                if (size > 0) {
+                    items.push({
+                        path: brewPath,
+                        size,
+                        name: brewPath.includes('Logs') ? 'Homebrew Logs' : 'Homebrew Cache',
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                    });
+                }
+            }
+            catch {
+                // Skip if cannot access
+            }
+        }
+        items.sort((a, b) => b.size - a.size);
+        return this.createResult(items);
+    }
+    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 brew cleanup first
+            await execAsync('brew cleanup --prune=all 2>/dev/null || true');
+            // Then remove remaining items
+            const result = await removeItems(items, false);
+            return {
+                category: this.category,
+                cleanedItems: result.success,
+                freedSpace: result.freedSpace,
+                errors: result.failed > 0 ? [`Failed to remove ${result.failed} items`] : [],
+            };
+        }
+        catch (error) {
+            // Fallback to manual removal
+            const result = await removeItems(items, false);
+            return {
+                category: this.category,
+                cleanedItems: result.success,
+                freedSpace: result.freedSpace,
+                errors: result.failed > 0 ? [`Failed to remove ${result.failed} items`] : [],
+            };
+        }
+    }
+}

package/dist/scanners/index.js

@@ -0,0 +1,126 @@
+import { UserCacheScanner } from './user-cache.js';
+import { UserLogsScanner } from './user-logs.js';
+import { TrashScanner } from './trash.js';
+import { BrowserCacheScanner } from './browser-cache.js';
+import { DevCacheScanner } from './dev-cache.js';
+import { XcodeScanner } from './xcode.js';
+import { DownloadsScanner } from './downloads.js';
+import { HomebrewScanner } from './homebrew.js';
+import { DockerScanner } from './docker.js';
+import { IosBackupsScanner } from './ios-backups.js';
+import { TempFilesScanner } from './temp-files.js';
+import { NodeModulesScanner } from './node-modules.js';
+import { InstallerScanner } from './installer.js';
+import pLimit from 'p-limit';
+// All available scanners
+const scanners = [
+    new UserCacheScanner(),
+    new UserLogsScanner(),
+    new TrashScanner(),
+    new BrowserCacheScanner(),
+    new DevCacheScanner(),
+    new XcodeScanner(),
+    new DownloadsScanner(),
+    new HomebrewScanner(),
+    new DockerScanner(),
+    new IosBackupsScanner(),
+    new TempFilesScanner(),
+    new NodeModulesScanner(),
+    new InstallerScanner(),
+];
+/**
+ * Get all scanners
+ */
+export function getAllScanners() {
+    return scanners;
+}
+/**
+ * Get scanner by category ID
+ */
+export function getScanner(categoryId) {
+    return scanners.find((s) => s.category.id === categoryId);
+}
+/**
+ * Run all scanners
+ */
+export async function runAllScans(options) {
+    const { parallel = true, concurrency = 4, onProgress } = options || {};
+    const results = [];
+    let completed = 0;
+    if (parallel) {
+        const limit = pLimit(concurrency);
+        const promises = scanners.map((scanner) => limit(async () => {
+            const result = await scanner.scan();
+            completed++;
+            onProgress?.(completed, scanners.length, scanner);
+            return result;
+        }));
+        const scanResults = await Promise.all(promises);
+        results.push(...scanResults);
+    }
+    else {
+        for (const scanner of scanners) {
+            const result = await scanner.scan();
+            results.push(result);
+            completed++;
+            onProgress?.(completed, scanners.length, scanner);
+        }
+    }
+    const totalSize = results.reduce((sum, r) => sum + r.totalSize, 0);
+    const totalItems = results.reduce((sum, r) => sum + r.items.length, 0);
+    return {
+        results,
+        totalSize,
+        totalItems,
+    };
+}
+/**
+ * Run specific scanners
+ */
+export async function runScans(categoryIds, options) {
+    const selectedScanners = scanners.filter((s) => categoryIds.includes(s.category.id));
+    const { parallel = true, concurrency = 4, onProgress } = options || {};
+    const results = [];
+    let completed = 0;
+    if (parallel) {
+        const limit = pLimit(concurrency);
+        const promises = selectedScanners.map((scanner) => limit(async () => {
+            const result = await scanner.scan();
+            completed++;
+            onProgress?.(completed, selectedScanners.length, scanner);
+            return result;
+        }));
+        const scanResults = await Promise.all(promises);
+        results.push(...scanResults);
+    }
+    else {
+        for (const scanner of selectedScanners) {
+            const result = await scanner.scan();
+            results.push(result);
+            completed++;
+            onProgress?.(completed, selectedScanners.length, scanner);
+        }
+    }
+    const totalSize = results.reduce((sum, r) => sum + r.totalSize, 0);
+    const totalItems = results.reduce((sum, r) => sum + r.items.length, 0);
+    return {
+        results,
+        totalSize,
+        totalItems,
+    };
+}
+// Export individual scanners
+export { UserCacheScanner } from './user-cache.js';
+export { UserLogsScanner } from './user-logs.js';
+export { TrashScanner } from './trash.js';
+export { BrowserCacheScanner } from './browser-cache.js';
+export { DevCacheScanner } from './dev-cache.js';
+export { XcodeScanner } from './xcode.js';
+export { DownloadsScanner } from './downloads.js';
+export { HomebrewScanner } from './homebrew.js';
+export { DockerScanner } from './docker.js';
+export { IosBackupsScanner } from './ios-backups.js';
+export { TempFilesScanner } from './temp-files.js';
+export { NodeModulesScanner } from './node-modules.js';
+export { InstallerScanner } from './installer.js';
+export { BaseScanner } from './base.js';

package/dist/scanners/installer.js

@@ -0,0 +1,87 @@
+/**
+ * Installer files scanner
+ */
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { BaseScanner } from './base.js';
+import { exists } from '../utils/fs.js';
+export class InstallerScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'app-data',
+            name: 'Installer Files',
+            group: 'Storage',
+            description: '.dmg, .pkg, .iso, .xip, .zip files',
+            safetyLevel: 'moderate',
+            safetyNote: 'Installer files that may no longer be needed',
+        };
+        this.searchPaths = [
+            join(homedir(), 'Downloads'),
+            join(homedir(), 'Desktop'),
+            join(homedir(), 'Documents'),
+        ];
+        this.installerExtensions = ['.dmg', '.pkg', '.mpkg', '.iso', '.xip'];
+    }
+    async scan(_options) {
+        const items = [];
+        for (const searchPath of this.searchPaths) {
+            try {
+                if (!exists(searchPath)) {
+                    continue;
+                }
+                await this.scanDirectory(searchPath, items, 2);
+            }
+            catch {
+                // Skip if cannot access
+            }
+        }
+        items.sort((a, b) => b.size - a.size);
+        return this.createResult(items);
+    }
+    async scanDirectory(dirPath, items, depth) {
+        if (depth <= 0) {
+            return;
+        }
+        try {
+            const entries = await readdir(dirPath);
+            for (const entry of entries) {
+                // Skip hidden files
+                if (entry.startsWith('.')) {
+                    continue;
+                }
+                const entryPath = join(dirPath, entry);
+                try {
+                    const stats = await stat(entryPath);
+                    if (stats.isDirectory()) {
+                        await this.scanDirectory(entryPath, items, depth - 1);
+                    }
+                    else if (this.isInstallerFile(entry)) {
+                        const size = stats.size;
+                        if (size > 1024 * 1024) {
+                            // > 1MB
+                            items.push({
+                                path: entryPath,
+                                size,
+                                name: entry,
+                                isDirectory: false,
+                                modifiedAt: stats.mtime,
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        catch {
+            // Skip if cannot access
+        }
+    }
+    isInstallerFile(filename) {
+        const lowerName = filename.toLowerCase();
+        return this.installerExtensions.some((ext) => lowerName.endsWith(ext));
+    }
+}

package/dist/scanners/ios-backups.js

@@ -0,0 +1,82 @@
+/**
+ * iOS Backups scanner
+ */
+import { readdir, stat, readFile } 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 IosBackupsScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'ios-backups',
+            name: 'iOS Backups',
+            group: 'Storage',
+            description: 'Local iPhone/iPad backup files',
+            safetyLevel: 'risky',
+            safetyNote: 'Backup data cannot be recovered after deletion',
+        };
+    }
+    async scan(_options) {
+        const items = [];
+        try {
+            if (!exists(paths.iosBackups)) {
+                return this.createResult([]);
+            }
+            const entries = await readdir(paths.iosBackups);
+            for (const entry of entries) {
+                // Skip .DS_Store
+                if (entry.startsWith('.')) {
+                    continue;
+                }
+                const backupPath = join(paths.iosBackups, entry);
+                try {
+                    const stats = await stat(backupPath);
+                    if (!stats.isDirectory()) {
+                        continue;
+                    }
+                    const size = await getSize(backupPath);
+                    const info = await this.getBackupInfo(backupPath);
+                    const name = info.deviceName
+                        ? `${info.deviceName} Backup`
+                        : `iOS Backup (${entry.substring(0, 8)})`;
+                    items.push({
+                        path: backupPath,
+                        size,
+                        name,
+                        isDirectory: true,
+                        modifiedAt: info.lastBackup || stats.mtime,
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+            items.sort((a, b) => b.size - a.size);
+            return this.createResult(items);
+        }
+        catch (error) {
+            return this.createResult([], error.message);
+        }
+    }
+    async getBackupInfo(backupPath) {
+        try {
+            const infoPath = join(backupPath, 'Info.plist');
+            if (!exists(infoPath)) {
+                return {};
+            }
+            const content = await readFile(infoPath, 'utf-8');
+            // Parse plist to get device name
+            const nameMatch = content.match(/<key>Device Name<\/key>\s*<string>([^<]+)<\/string>/);
+            const dateMatch = content.match(/<key>Last Backup Date<\/key>\s*<date>([^<]+)<\/date>/);
+            return {
+                deviceName: nameMatch?.[1],
+                lastBackup: dateMatch?.[1] ? new Date(dateMatch[1]) : undefined,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/scanners/node-modules.js

@@ -0,0 +1,75 @@
+/**
+ * Node modules scanner (project artifacts)
+ */
+import { stat, access } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { BaseScanner } from './base.js';
+import { getSize } from '../utils/fs.js';
+import fg from 'fast-glob';
+export class NodeModulesScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'node-modules',
+            name: 'Node Modules',
+            group: 'Development',
+            description: 'node_modules directories in projects',
+            safetyLevel: 'moderate',
+            safetyNote: 'Can be reinstalled with npm/yarn/pnpm install',
+        };
+        this.defaultSearchPaths = [
+            join(homedir(), 'Projects'),
+            join(homedir(), 'Developer'),
+            join(homedir(), 'Code'),
+            join(homedir(), 'Documents'),
+            join(homedir(), 'Desktop'),
+        ];
+    }
+    async scan(options) {
+        const items = [];
+        const minSize = options?.minSize ?? 10 * 1024 * 1024; // 10MB default
+        // Find all node_modules directories
+        for (const searchPath of this.defaultSearchPaths) {
+            try {
+                await access(searchPath);
+                // Use fast-glob to find node_modules
+                const nodeModulesDirs = await fg('**/node_modules', {
+                    cwd: searchPath,
+                    onlyDirectories: true,
+                    deep: 5,
+                    followSymbolicLinks: false,
+                    ignore: ['**/node_modules/**/node_modules'], // Don't scan nested node_modules
+                });
+                for (const relPath of nodeModulesDirs) {
+                    const fullPath = join(searchPath, relPath);
+                    try {
+                        const stats = await stat(fullPath);
+                        const size = await getSize(fullPath);
+                        if (size >= minSize) {
+                            // Get project name from parent directory
+                            const projectPath = fullPath.replace('/node_modules', '');
+                            const projectName = projectPath.split('/').pop() || 'Unknown';
+                            items.push({
+                                path: fullPath,
+                                size,
+                                name: `${projectName}/node_modules`,
+                                isDirectory: true,
+                                modifiedAt: stats.mtime,
+                            });
+                        }
+                    }
+                    catch {
+                        // Skip if cannot access
+                    }
+                }
+            }
+            catch {
+                // Search path doesn't exist
+            }
+        }
+        items.sort((a, b) => b.size - a.size);
+        // Limit to top 100 to avoid overwhelming the user
+        return this.createResult(items.slice(0, 100));
+    }
+}

package/dist/scanners/temp-files.js

@@ -0,0 +1,65 @@
+/**
+ * Temporary files 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 TempFilesScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'temp-files',
+            name: 'Temporary Files',
+            group: 'System Junk',
+            description: 'System and user temporary files',
+            safetyLevel: 'safe',
+        };
+        this.tempPaths = Object.values(paths.tempFiles);
+    }
+    async scan(_options) {
+        const items = [];
+        for (const tempPath of this.tempPaths) {
+            try {
+                if (!exists(tempPath)) {
+                    continue;
+                }
+                const entries = await readdir(tempPath);
+                for (const entry of entries) {
+                    // Skip important system files
+                    if (entry.startsWith('.') || entry === 'com.apple.launchd') {
+                        continue;
+                    }
+                    const entryPath = join(tempPath, entry);
+                    try {
+                        const stats = await stat(entryPath);
+                        // Only include files older than 1 day
+                        const oneDayAgo = new Date();
+                        oneDayAgo.setDate(oneDayAgo.getDate() - 1);
+                        if (stats.mtime < oneDayAgo) {
+                            const size = await getSize(entryPath);
+                            if (size > 0) {
+                                items.push({
+                                    path: entryPath,
+                                    size,
+                                    name: entry,
+                                    isDirectory: stats.isDirectory(),
+                                    modifiedAt: stats.mtime,
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip if cannot access
+                    }
+                }
+            }
+            catch {
+                // Skip if cannot access directory
+            }
+        }
+        items.sort((a, b) => b.size - a.size);
+        return this.createResult(items);
+    }
+}

package/dist/scanners/trash.js

@@ -0,0 +1,90 @@
+/**
+ * Trash 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, removeItems } from '../utils/fs.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class TrashScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.category = {
+            id: 'trash',
+            name: 'Trash',
+            group: 'Storage',
+            description: 'Files in Trash',
+            safetyLevel: 'safe',
+        };
+    }
+    async scan(_options) {
+        const items = [];
+        try {
+            if (!exists(paths.trash)) {
+                return this.createResult([]);
+            }
+            const entries = await readdir(paths.trash);
+            for (const entry of entries) {
+                // Skip .DS_Store
+                if (entry === '.DS_Store') {
+                    continue;
+                }
+                const entryPath = join(paths.trash, entry);
+                try {
+                    const stats = await stat(entryPath);
+                    const size = await getSize(entryPath);
+                    items.push({
+                        path: entryPath,
+                        size,
+                        name: entry,
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+            items.sort((a, b) => b.size - a.size);
+            return this.createResult(items);
+        }
+        catch (error) {
+            return this.createResult([], error.message);
+        }
+    }
+    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 {
+            // Use AppleScript to empty trash properly
+            await execAsync('osascript -e \'tell application "Finder" to empty trash\'');
+            const totalSize = items.reduce((sum, item) => sum + item.size, 0);
+            return {
+                category: this.category,
+                cleanedItems: items.length,
+                freedSpace: totalSize,
+                errors: [],
+            };
+        }
+        catch (error) {
+            // Fallback to manual removal
+            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`] : [],
+            };
+        }
+    }
+}