@tukuyomil032/broom 1.0.0

package/dist/commands/doctor.js

@@ -0,0 +1,280 @@
+/**
+ * Doctor command - System health diagnostics
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { execSync } from 'child_process';
+import { expandPath, exists, formatSize } from '../utils/fs.js';
+import { printHeader, separator, warning, success, error } from '../ui/output.js';
+/**
+ * Check disk usage
+ */
+async function checkDiskUsage() {
+    try {
+        const output = execSync("df -k / | tail -1 | awk '{print $2, $3, $4, $5}'").toString().trim();
+        const [total, used, free, percentStr] = output.split(' ');
+        const percent = parseInt(percentStr);
+        let status = 'healthy';
+        let message = `Disk usage: ${percent}%`;
+        let recommendation;
+        if (percent >= 90) {
+            status = 'critical';
+            recommendation = 'Critically low disk space! Run "broom clean" immediately';
+        }
+        else if (percent >= 80) {
+            status = 'warning';
+            recommendation = 'Disk space running low. Consider cleaning up';
+        }
+        return {
+            name: 'Disk Usage',
+            status,
+            message,
+            recommendation,
+            value: `${formatSize(parseInt(used) * 1024)} / ${formatSize(parseInt(total) * 1024)}`,
+        };
+    }
+    catch {
+        return {
+            name: 'Disk Usage',
+            status: 'warning',
+            message: 'Unable to check disk usage',
+        };
+    }
+}
+/**
+ * Find large files (>1GB)
+ */
+async function checkLargeFiles() {
+    try {
+        const homePath = expandPath('~');
+        const output = execSync(`find "${homePath}" -type f -size +1G 2>/dev/null | head -20`).toString();
+        const files = output
+            .trim()
+            .split('\n')
+            .filter((f) => f);
+        let status = 'healthy';
+        let message = 'No large files found';
+        let recommendation;
+        if (files.length > 0) {
+            status = files.length > 10 ? 'warning' : 'healthy';
+            message = `${files.length} files larger than 1GB`;
+            if (files.length > 10) {
+                recommendation = 'Review and clean up large files';
+            }
+        }
+        return {
+            name: 'Large Files',
+            status,
+            message,
+            recommendation,
+            value: files.length > 0 ? `${files.length} files` : undefined,
+        };
+    }
+    catch {
+        return {
+            name: 'Large Files',
+            status: 'healthy',
+            message: 'No large files detected',
+        };
+    }
+}
+/**
+ * Check for broken symlinks
+ */
+async function checkBrokenSymlinks() {
+    try {
+        const homePath = expandPath('~');
+        const output = execSync(`find "${homePath}" -type l ! -exec test -e {} \\; -print 2>/dev/null | head -50`).toString();
+        const brokenLinks = output
+            .trim()
+            .split('\n')
+            .filter((f) => f);
+        let status = 'healthy';
+        let message = 'No broken symlinks';
+        let recommendation;
+        if (brokenLinks.length > 0) {
+            status = brokenLinks.length > 10 ? 'warning' : 'healthy';
+            message = `${brokenLinks.length} broken symlinks detected`;
+            if (brokenLinks.length > 10) {
+                recommendation = 'Clean up broken symlinks';
+            }
+        }
+        return {
+            name: 'Broken Symlinks',
+            status,
+            message,
+            recommendation,
+            value: brokenLinks.length > 0 ? `${brokenLinks.length} links` : undefined,
+        };
+    }
+    catch {
+        return {
+            name: 'Broken Symlinks',
+            status: 'healthy',
+            message: 'No broken symlinks found',
+        };
+    }
+}
+/**
+ * Check for old files (not accessed in 1 year)
+ */
+async function checkOldFiles() {
+    try {
+        const homePath = expandPath('~');
+        const output = execSync(`find "${homePath}/Downloads" "${homePath}/Documents" -type f -atime +365 2>/dev/null | head -100`).toString();
+        const oldFiles = output
+            .trim()
+            .split('\n')
+            .filter((f) => f);
+        let status = 'healthy';
+        let message = 'No old files found';
+        let recommendation;
+        if (oldFiles.length > 0) {
+            status = oldFiles.length > 50 ? 'warning' : 'healthy';
+            message = `${oldFiles.length}+ files not accessed in 1 year`;
+            if (oldFiles.length > 50) {
+                recommendation = 'Consider archiving or removing old files';
+            }
+        }
+        return {
+            name: 'Old Files',
+            status,
+            message,
+            recommendation,
+            value: oldFiles.length > 0 ? `${oldFiles.length}+ files` : undefined,
+        };
+    }
+    catch {
+        return {
+            name: 'Old Files',
+            status: 'healthy',
+            message: 'No old files detected',
+        };
+    }
+}
+/**
+ * Check common cache directories
+ */
+async function checkCacheSizes() {
+    const cachePaths = [
+        expandPath('~/Library/Caches'),
+        expandPath('~/Library/Logs'),
+        expandPath('~/.npm'),
+        expandPath('~/.cache'),
+    ];
+    let totalSize = 0;
+    for (const path of cachePaths) {
+        if (exists(path)) {
+            try {
+                const output = execSync(`du -sk "${path}" 2>/dev/null`).toString();
+                const size = parseInt(output.split('\t')[0]) * 1024;
+                totalSize += size;
+            }
+            catch {
+                // Skip if cannot read
+            }
+        }
+    }
+    let status = 'healthy';
+    let message = 'Cache size is reasonable';
+    let recommendation;
+    const GB = 1024 * 1024 * 1024;
+    if (totalSize > 10 * GB) {
+        status = 'warning';
+        message = `Large cache detected: ${formatSize(totalSize)}`;
+        recommendation = 'Run "broom clean" to free up cache space';
+    }
+    else if (totalSize > 5 * GB) {
+        status = 'healthy';
+        message = `Cache size: ${formatSize(totalSize)}`;
+    }
+    return {
+        name: 'Cache Size',
+        status,
+        message,
+        recommendation,
+        value: formatSize(totalSize),
+    };
+}
+/**
+ * Get status icon
+ */
+function getStatusIcon(status) {
+    switch (status) {
+        case 'healthy':
+            return chalk.green('✓');
+        case 'warning':
+            return chalk.yellow('⚠️ ');
+        case 'critical':
+            return chalk.red('❌');
+    }
+}
+/**
+ * Execute doctor command
+ */
+export async function doctorCommand(options) {
+    printHeader('🏥 System Health Check');
+    console.log(chalk.dim('Running diagnostics...'));
+    console.log();
+    // Run all health checks
+    const checks = await Promise.all([
+        checkDiskUsage(),
+        checkCacheSizes(),
+        checkLargeFiles(),
+        checkBrokenSymlinks(),
+        checkOldFiles(),
+    ]);
+    // Display results
+    for (const check of checks) {
+        const icon = getStatusIcon(check.status);
+        const statusColor = check.status === 'healthy'
+            ? chalk.green
+            : check.status === 'warning'
+                ? chalk.yellow
+                : chalk.red;
+        console.log(`${icon} ${chalk.bold(check.name)}: ${check.message}`);
+        if (check.value && options.verbose) {
+            console.log(chalk.dim(`   Value: ${check.value}`));
+        }
+        if (check.recommendation) {
+            console.log(chalk.dim(`   → ${check.recommendation}`));
+        }
+        console.log();
+    }
+    // Summary
+    separator();
+    console.log();
+    const healthyCount = checks.filter((c) => c.status === 'healthy').length;
+    const warningCount = checks.filter((c) => c.status === 'warning').length;
+    const criticalCount = checks.filter((c) => c.status === 'critical').length;
+    console.log(chalk.bold('📊 Summary:'));
+    console.log(`  ${chalk.green('●')} Healthy: ${healthyCount}`);
+    console.log(`  ${chalk.yellow('●')} Warning: ${warningCount}`);
+    console.log(`  ${chalk.red('●')} Critical: ${criticalCount}`);
+    console.log();
+    if (criticalCount > 0) {
+        error('Critical issues detected! Please take action immediately.');
+    }
+    else if (warningCount > 0) {
+        warning('Some issues detected. Consider cleaning up.');
+    }
+    else {
+        success('Your system looks healthy!');
+    }
+    console.log();
+    console.log(chalk.dim('Tip: Run "broom clean" to free up space'));
+    console.log(chalk.dim('     Run "broom doctor --verbose" for detailed information'));
+}
+/**
+ * Create doctor command
+ */
+export function createDoctorCommand() {
+    const cmd = new Command('doctor')
+        .description('Run system health diagnostics')
+        .option('-v, --verbose', 'Show detailed information')
+        .action(async (options) => {
+        await doctorCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/duplicates.js

@@ -0,0 +1,325 @@
+/**
+ * Duplicates command - Find and remove duplicate files
+ */
+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, createSpinner, succeedSpinner, } from '../ui/output.js';
+import { readdir, stat, unlink } from 'fs/promises';
+import { join, relative } from 'path';
+import { createHash } from 'crypto';
+import { createReadStream } from 'fs';
+/**
+ * Parse size string (e.g., "1MB", "500KB", "2GB")
+ */
+function parseSize(sizeStr) {
+    const match = sizeStr.match(/^(\d+(?:\.\d+)?)(KB|MB|GB)?$/i);
+    if (!match) {
+        throw new Error(`Invalid size format: ${sizeStr}`);
+    }
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 'B').toUpperCase();
+    switch (unit) {
+        case 'KB':
+            return value * 1024;
+        case 'MB':
+            return value * 1024 * 1024;
+        case 'GB':
+            return value * 1024 * 1024 * 1024;
+        default:
+            return value;
+    }
+}
+/**
+ * Calculate file hash
+ */
+async function calculateFileHash(filePath, algorithm = 'sha256') {
+    return new Promise((resolve, reject) => {
+        const hash = createHash(algorithm);
+        const stream = createReadStream(filePath);
+        stream.on('data', (data) => hash.update(data));
+        stream.on('end', () => resolve(hash.digest('hex')));
+        stream.on('error', reject);
+    });
+}
+/**
+ * Optimized hash calculation for large files
+ */
+async function calculateSmartHash(filePath, fileSize) {
+    // For small files (<1MB), use full hash
+    if (fileSize < 1024 * 1024) {
+        return await calculateFileHash(filePath, 'sha256');
+    }
+    // For large files, use size + partial hash
+    const partialHash = await calculatePartialHash(filePath);
+    return `${fileSize}:${partialHash}`;
+}
+/**
+ * Calculate partial hash (first and last 64KB)
+ */
+async function calculatePartialHash(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const stream = createReadStream(filePath, {
+            start: 0,
+            end: 64 * 1024, // First 64KB
+        });
+        stream.on('data', (data) => hash.update(data));
+        stream.on('end', () => {
+            // Also read last 64KB
+            const endStream = createReadStream(filePath, {
+                start: -64 * 1024,
+            });
+            endStream.on('data', (data) => hash.update(data));
+            endStream.on('end', () => resolve(hash.digest('hex')));
+            endStream.on('error', reject);
+        });
+        stream.on('error', reject);
+    });
+}
+/**
+ * Get all files recursively
+ */
+async function getAllFiles(dirPath, minSize = 0, files = []) {
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry.name);
+            // Skip hidden files and system directories
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.isDirectory()) {
+                await getAllFiles(fullPath, minSize, files);
+            }
+            else if (entry.isFile()) {
+                const stats = await stat(fullPath);
+                if (stats.size >= minSize) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Skip directories we cannot read
+    }
+    return files;
+}
+/**
+ * Find duplicates
+ */
+async function findDuplicates(paths, minSize = 0, hashAlgorithm = 'sha256') {
+    const spinner = createSpinner('Scanning files...');
+    // Get all files
+    const allFiles = [];
+    for (const path of paths) {
+        await getAllFiles(path, minSize, allFiles);
+    }
+    succeedSpinner(spinner, `Found ${allFiles.length} files`);
+    // Group by size first (optimization)
+    const sizeGroups = new Map();
+    for (const file of allFiles) {
+        const stats = await stat(file);
+        const size = stats.size;
+        if (!sizeGroups.has(size)) {
+            sizeGroups.set(size, []);
+        }
+        sizeGroups.get(size).push(file);
+    }
+    // Only hash files with duplicate sizes
+    const hashSpinner = createSpinner('Calculating hashes...');
+    const hashMap = new Map();
+    let processed = 0;
+    for (const [size, files] of sizeGroups.entries()) {
+        if (files.length > 1) {
+            // Multiple files with same size - need to hash
+            for (const file of files) {
+                const hash = await calculateSmartHash(file, size);
+                if (!hashMap.has(hash)) {
+                    hashMap.set(hash, []);
+                }
+                hashMap.get(hash).push(file);
+                processed++;
+                if (processed % 10 === 0) {
+                    hashSpinner.text = `Hashing files... (${processed}/${files.length * sizeGroups.size})`;
+                }
+            }
+        }
+    }
+    succeedSpinner(hashSpinner, `Hashed ${processed} files`);
+    // Return only groups with duplicates
+    return new Map([...hashMap.entries()].filter(([_, files]) => files.length > 1));
+}
+/**
+ * Interactive duplicate handler
+ */
+async function handleDuplicatesInteractive(duplicates) {
+    const { select } = await import('../ui/prompts.js');
+    const cwd = process.cwd();
+    let groupIndex = 1;
+    for (const [hash, files] of duplicates.entries()) {
+        console.log();
+        console.log(chalk.bold(`Group ${groupIndex} (${files.length} files, ${formatSize((await stat(files[0])).size)} each):`));
+        console.log();
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const stats = await stat(file);
+            const relPath = relative(cwd, file);
+            const modTime = new Date(stats.mtime).toLocaleString('ja-JP');
+            // Create clickable file link (Cmd+Click in terminal opens in Finder)
+            console.log(`  ${i + 1}. ${chalk.cyan.underline(`file://${file}`)}`);
+            console.log(`     ${chalk.dim(`└─ ${relPath}`)}`);
+            console.log(`     ${chalk.dim(`   Modified: ${modTime}`)}`);
+        }
+        console.log();
+        const action = await select({
+            message: 'What would you like to do?',
+            choices: [
+                { name: 'Keep first, delete others', value: 'delete-others' },
+                { name: 'Keep last, delete others', value: 'delete-except-last' },
+                { name: 'Skip this group', value: 'skip' },
+                { name: 'Hardlink duplicates', value: 'hardlink' },
+                { name: 'Exit', value: 'exit' },
+            ],
+        });
+        if (action === 'exit') {
+            break;
+        }
+        if (action === 'skip') {
+            groupIndex++;
+            continue;
+        }
+        if (action === 'delete-others') {
+            for (let i = 1; i < files.length; i++) {
+                await unlink(files[i]);
+                console.log(chalk.dim(`  Deleted: ${files[i]}`));
+            }
+            success(`Kept: ${files[0]}`);
+        }
+        else if (action === 'delete-except-last') {
+            for (let i = 0; i < files.length - 1; i++) {
+                await unlink(files[i]);
+                console.log(chalk.dim(`  Deleted: ${files[i]}`));
+            }
+            success(`Kept: ${files[files.length - 1]}`);
+        }
+        else if (action === 'hardlink') {
+            // Keep first, hardlink others
+            for (let i = 1; i < files.length; i++) {
+                await unlink(files[i]);
+                const { execSync } = await import('child_process');
+                execSync(`ln "${files[0]}" "${files[i]}"`);
+                console.log(chalk.dim(`  Hardlinked: ${files[i]} -> ${files[0]}`));
+            }
+            success('Created hardlinks');
+        }
+        groupIndex++;
+    }
+}
+/**
+ * Validate and get scan path
+ */
+async function getValidPath(initialPath) {
+    const { input } = await import('../ui/prompts.js');
+    let path = initialPath ? expandPath(initialPath) : expandPath('~');
+    // If path provided via option, validate it
+    if (initialPath) {
+        const pathExists = await exists(path);
+        if (!pathExists) {
+            error(`Path does not exist: ${path}`);
+            console.log();
+            // Prompt for valid path
+            while (true) {
+                const newPath = await input({
+                    message: 'Enter a valid path to scan:',
+                    default: expandPath('~'),
+                });
+                const expandedPath = expandPath(newPath);
+                const pathExists = await exists(expandedPath);
+                if (pathExists) {
+                    path = expandedPath;
+                    break;
+                }
+                else {
+                    error(`Path does not exist: ${expandedPath}`);
+                    console.log();
+                }
+            }
+        }
+    }
+    return path;
+}
+/**
+ * Execute duplicates command
+ */
+export async function duplicatesCommand(options) {
+    const path = await getValidPath(options.path);
+    const paths = [path];
+    const minSize = options.minSize ? parseSize(options.minSize) : 1024 * 1024; // Default 1MB
+    const hashAlgorithm = options.hash || 'sha256';
+    printHeader('🔍 Duplicate File Finder');
+    console.log(chalk.dim(`Scanning: ${paths.join(', ')}`));
+    console.log(chalk.dim(`Min size: ${formatSize(minSize)}`));
+    console.log(chalk.dim(`Hash algorithm: ${hashAlgorithm}`));
+    console.log();
+    const duplicates = await findDuplicates(paths, minSize, hashAlgorithm);
+    if (duplicates.size === 0) {
+        success('No duplicates found!');
+        return;
+    }
+    // Calculate potential space savings
+    let totalSavings = 0;
+    for (const [_, files] of duplicates.entries()) {
+        const fileSize = (await stat(files[0])).size;
+        totalSavings += fileSize * (files.length - 1);
+    }
+    console.log();
+    separator();
+    console.log();
+    console.log(chalk.bold('📊 Summary:'));
+    console.log(`  Duplicate groups: ${duplicates.size}`);
+    console.log(`  Potential savings: ${chalk.yellow(formatSize(totalSavings))}`);
+    console.log();
+    if (options.interactive || options.delete) {
+        await handleDuplicatesInteractive(duplicates);
+    }
+    else {
+        // Just list duplicates with details
+        const cwd = process.cwd();
+        let groupIndex = 1;
+        for (const [_, files] of duplicates.entries()) {
+            const fileSize = (await stat(files[0])).size;
+            console.log(chalk.bold(`Group ${groupIndex} (${files.length} files, ${formatSize(fileSize)} each):`));
+            console.log();
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const stats = await stat(file);
+                const relPath = relative(cwd, file);
+                const modTime = new Date(stats.mtime).toLocaleString('ja-JP');
+                // Create clickable file link
+                console.log(`  ${i + 1}. ${chalk.cyan.underline(`file://${file}`)}`);
+                console.log(`     ${chalk.dim(`└─ ${relPath}`)}`);
+                console.log(`     ${chalk.dim(`   Modified: ${modTime}`)}`);
+            }
+            console.log();
+            groupIndex++;
+        }
+        console.log(chalk.dim('Use --interactive to select which files to keep/delete'));
+    }
+}
+/**
+ * Create duplicates command
+ */
+export function createDuplicatesCommand() {
+    const cmd = new Command('duplicates')
+        .description('Find and remove duplicate files')
+        .option('-p, --path <path>', 'Path to scan (default: home directory)')
+        .option('--min-size <size>', 'Minimum file size (e.g., 1MB, 500KB)', '1MB')
+        .option('--hash <algorithm>', 'Hash algorithm (md5 or sha256)', 'sha256')
+        .option('-i, --interactive', 'Interactive mode to choose which files to delete')
+        .option('-d, --delete', 'Automatically delete duplicates (keep first)')
+        .action(async (options) => {
+        await duplicatesCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/help.js

@@ -0,0 +1,34 @@
+/**
+ * Help command - Display help for any command
+ */
+import { Command } from 'commander';
+import { formatCommandHelp } from '../utils/help.js';
+import { info } from '../ui/output.js';
+let allCommands = [];
+export function setCommandsList(commands) {
+    allCommands = commands;
+}
+export function createHelpCommand() {
+    return new Command('help')
+        .description('Display help for a command')
+        .argument('[command]', 'The command to get help for')
+        .action((commandName) => {
+        if (!commandName) {
+            info('Usage: broom help <command>');
+            info('');
+            info('Examples:');
+            info('  broom help clean');
+            info('  broom help analyze');
+            info('  broom help uninstall');
+            return;
+        }
+        // Find the specified command
+        const command = allCommands.find((cmd) => cmd.name() === commandName);
+        if (!command) {
+            info(`Error: Unknown command "${commandName}"`);
+            process.exit(1);
+        }
+        // Display the command help
+        info(formatCommandHelp(command));
+    });
+}

package/dist/commands/index.js

@@ -0,0 +1,22 @@
+/**
+ * Commands module exports
+ */
+export { createCleanCommand } from './clean.js';
+export { createUninstallCommand } from './uninstall.js';
+export { createOptimizeCommand } from './optimize.js';
+export { createAnalyzeCommand } from './analyze.js';
+export { createStatusCommand } from './status.js';
+export { createPurgeCommand } from './purge.js';
+export { createInstallerCommand } from './installer.js';
+export { createTouchIdCommand } from './touchid.js';
+export { createCompletionCommand } from './completion.js';
+export { createUpdateCommand } from './update.js';
+export { createRemoveCommand } from './remove.js';
+export { createConfigCommand } from './config.js';
+export { createDoctorCommand } from './doctor.js';
+export { createBackupCommand, createRestoreCommand } from './backup.js';
+export { createDuplicatesCommand } from './duplicates.js';
+export { createScheduleCommand } from './schedule.js';
+export { createWatchCommand } from './watch.js';
+export { createReportsCommand } from './reports.js';
+export { createHelpCommand, setCommandsList } from './help.js';