@tukuyomil032/broom 1.0.0

package/dist/commands/analyze.js

@@ -0,0 +1,371 @@
+/**
+ * Analyze command - Disk space analysis with drill-down
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { readdir, stat } from 'fs/promises';
+import { join, basename } from 'path';
+import { exists, getSize, formatSize, expandPath } from '../utils/fs.js';
+import { printHeader, warning, info, separator, createSpinner, succeedSpinner, failSpinner, } from '../ui/output.js';
+// Fixed column widths for aligned display
+const NAME_WIDTH = 25;
+const BAR_WIDTH = 30;
+/**
+ * Scan directory for sizes
+ */
+async function scanDirectory(dirPath, depth, currentDepth = 0) {
+    try {
+        const stats = await stat(dirPath);
+        const name = basename(dirPath) || dirPath;
+        if (!stats.isDirectory()) {
+            return {
+                path: dirPath,
+                name,
+                size: stats.size,
+                isDirectory: false,
+            };
+        }
+        // Get total size
+        const size = await getSize(dirPath);
+        const info = {
+            path: dirPath,
+            name,
+            size,
+            isDirectory: true,
+        };
+        // Get children if within depth
+        if (currentDepth < depth) {
+            try {
+                const entries = await readdir(dirPath);
+                const children = [];
+                for (const entry of entries) {
+                    // Skip hidden files at top level
+                    if (entry.startsWith('.') && currentDepth === 0) {
+                        continue;
+                    }
+                    const childPath = join(dirPath, entry);
+                    // Skip excluded paths (iCloud Drive, etc.)
+                    const { isExcludedPath } = await import('../utils/fs.js');
+                    if (isExcludedPath(childPath)) {
+                        continue;
+                    }
+                    try {
+                        const childStats = await stat(childPath);
+                        const childSize = childStats.isDirectory() ? await getSize(childPath) : childStats.size;
+                        children.push({
+                            path: childPath,
+                            name: entry,
+                            size: childSize,
+                            isDirectory: childStats.isDirectory(),
+                        });
+                    }
+                    catch {
+                        // Skip if cannot access
+                    }
+                }
+                // Sort by size descending
+                children.sort((a, b) => b.size - a.size);
+                info.children = children;
+            }
+            catch {
+                // Cannot read directory
+            }
+        }
+        return info;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate size bar for Quick Analysis - with borders and gridlines
+ */
+function generateQuickAnalysisBar(size, maxSize, width = 20) {
+    const percentage = maxSize > 0 ? size / maxSize : 0;
+    const filledWidth = Math.round(percentage * width);
+    let bar = '';
+    // Color based on relative size
+    let color;
+    if (percentage > 0.7) {
+        color = chalk.red;
+    }
+    else if (percentage > 0.3) {
+        color = chalk.hex('#FFA500'); // Orange
+    }
+    else {
+        color = chalk.gray;
+    }
+    // Build bar with gridlines every 20%
+    for (let i = 0; i < width; i++) {
+        const isGridline = i > 0 && i % (width / 5) === 0;
+        if (i < filledWidth) {
+            bar += isGridline ? chalk.white('│') : color('█');
+        }
+        else {
+            bar += isGridline ? chalk.gray('│') : chalk.gray('░');
+        }
+    }
+    // Add horizontal borders
+    return chalk.gray('│') + bar + chalk.gray('│');
+}
+/**
+ * Generate size bar for tree display with gridlines
+ */
+function generateTreeBar(size, maxSize, width = BAR_WIDTH) {
+    const percentage = maxSize > 0 ? size / maxSize : 0;
+    const filledWidth = Math.round(percentage * width);
+    // Build bar with gridlines every 20%
+    let bar = '';
+    for (let i = 0; i < width; i++) {
+        const isGridline = i > 0 && i % (width / 5) === 0;
+        if (i < filledWidth) {
+            // Filled portion with color gradient
+            const ratio = i / width;
+            let fillChar;
+            if (ratio < 0.4) {
+                fillChar = chalk.bgGreen.green('█');
+            }
+            else if (ratio < 0.7) {
+                fillChar = chalk.bgYellow.yellow('█');
+            }
+            else {
+                fillChar = chalk.bgRed.red('█');
+            }
+            if (isGridline) {
+                bar += chalk.white('│');
+            }
+            else {
+                bar += fillChar;
+            }
+        }
+        else {
+            // Empty portion
+            if (isGridline) {
+                bar += chalk.gray('│');
+            }
+            else {
+                bar += chalk.gray('░');
+            }
+        }
+    }
+    // Add border
+    return chalk.gray('│') + bar + chalk.gray('│');
+}
+/**
+ * Generate disk usage bar with scale markers and gradient colors
+ */
+function generateDiskBar(used, total, width = 40) {
+    const percentage = total > 0 ? used / total : 0;
+    const filledWidth = Math.round(percentage * width);
+    // Scale header
+    const scale = chalk.gray('0%       20%       40%       60%       80%      100%');
+    // Build top border with horizontal gridlines
+    let topBorder = chalk.gray('╔');
+    for (let i = 0; i < width; i++) {
+        const isGridline = i > 0 && i % (width / 5) === 0;
+        topBorder += isGridline ? chalk.white('┬') : chalk.gray('═');
+    }
+    topBorder += chalk.gray('╗') + '\n';
+    // Build main bar with gradient
+    let bar = chalk.gray('║');
+    for (let i = 0; i < width; i++) {
+        const isVerticalGridline = i > 0 && i % (width / 5) === 0;
+        if (i < filledWidth) {
+            // Gradient color calculation (green → yellow → red)
+            const ratio = i / width;
+            let color;
+            if (ratio < 0.5) {
+                // Green to Yellow gradient (0-50%)
+                const localRatio = ratio / 0.5;
+                const r = Math.round(16 + (245 - 16) * localRatio);
+                const g = Math.round(185 + (158 - 185) * localRatio);
+                const b = Math.round(129 + (11 - 129) * localRatio);
+                color = chalk.rgb(r, g, b);
+            }
+            else {
+                // Yellow to Red gradient (50-100%)
+                const localRatio = (ratio - 0.5) / 0.5;
+                const r = 239;
+                const g = Math.round(158 - (158 - 68) * localRatio);
+                const b = Math.round(11 - 11 * localRatio);
+                color = chalk.rgb(r, g, b);
+            }
+            bar += isVerticalGridline ? chalk.white('│') : color('█');
+        }
+        else {
+            bar += isVerticalGridline ? chalk.gray('│') : chalk.gray('░');
+        }
+    }
+    bar += chalk.gray('║') + '\n';
+    // Build bottom border with horizontal gridlines
+    let bottomBorder = chalk.gray('╚');
+    for (let i = 0; i < width; i++) {
+        const isGridline = i > 0 && i % (width / 5) === 0;
+        bottomBorder += isGridline ? chalk.white('┴') : chalk.gray('═');
+    }
+    bottomBorder += chalk.gray('╝');
+    return scale + '\n' + topBorder + bar + bottomBorder;
+}
+/**
+ * Print directory tree with aligned columns
+ */
+function printTree(items, maxSize, limit, indent = '') {
+    const displayed = items.slice(0, limit);
+    const remaining = items.length - limit;
+    // Calculate maximum name width from displayed items (with reasonable limit)
+    const MAX_NAME_WIDTH = 40; // Maximum width to prevent excessive spacing
+    const maxNameLength = Math.min(Math.max(...displayed.map((item) => item.name.length), NAME_WIDTH // Minimum width
+    ), MAX_NAME_WIDTH // Maximum width
+    );
+    for (let i = 0; i < displayed.length; i++) {
+        const item = displayed[i];
+        const isLast = i === displayed.length - 1 && remaining <= 0;
+        const prefix = isLast ? '└── ' : '├── ';
+        const icon = item.isDirectory ? '📁' : '📄';
+        // Truncate or pad name to max width (show start and end)
+        let displayName = item.name;
+        if (displayName.length > maxNameLength) {
+            const keepLength = Math.floor((maxNameLength - 3) / 2);
+            displayName =
+                displayName.substring(0, keepLength) +
+                    '...' +
+                    displayName.substring(displayName.length - keepLength);
+        }
+        displayName = displayName.padEnd(maxNameLength);
+        const bar = generateTreeBar(item.size, maxSize);
+        const sizeStr = formatSize(item.size).padStart(10);
+        const percentage = maxSize > 0 ? ((item.size / maxSize) * 100).toFixed(1).padStart(5) + '%' : '  0.0%';
+        console.log(`${indent}${prefix}${icon} ${chalk.bold(displayName)} ${bar} ${chalk.cyan(sizeStr)} ${chalk.dim(percentage)}`);
+    }
+    if (remaining > 0) {
+        console.log(chalk.dim(`${indent}    ... and ${remaining} more items`));
+    }
+}
+/**
+ * Get disk usage info
+ */
+async function getDiskUsage() {
+    try {
+        const { execSync } = await import('child_process');
+        const output = execSync("df -k / | tail -1 | awk '{print $2, $3, $4}'").toString().trim();
+        const [total, used, free] = output.split(' ').map((n) => parseInt(n) * 1024);
+        return { total, used, free };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Execute analyze command
+ */
+export async function analyzeCommand(options) {
+    const targetPath = options.path ? expandPath(options.path) : expandPath('~');
+    const depth = options.depth ?? 1;
+    const limit = options.limit ?? 15;
+    printHeader(`📊 Disk Space Analysis`);
+    // Show disk usage with improved bar
+    const diskUsage = await getDiskUsage();
+    if (diskUsage) {
+        console.log(chalk.bold('💾 Disk Usage:'));
+        const usedPercent = (diskUsage.used / diskUsage.total) * 100;
+        console.log(generateDiskBar(diskUsage.used, diskUsage.total));
+        console.log();
+        console.log(`  Used: ${chalk.yellow(formatSize(diskUsage.used))} / ${formatSize(diskUsage.total)} (${usedPercent.toFixed(1)}%)`);
+        console.log(`  Free: ${chalk.green(formatSize(diskUsage.free))}`);
+        console.log();
+    }
+    // Scan target directory
+    info(`Analyzing system disk...`);
+    console.log(chalk.bold(`Target: ${chalk.cyan(targetPath)}`));
+    console.log();
+    const spinner = createSpinner('Scanning directory sizes...');
+    const dirInfo = await scanDirectory(targetPath, depth);
+    if (!dirInfo) {
+        failSpinner(spinner, 'Failed to scan directory');
+        return;
+    }
+    succeedSpinner(spinner, `Scanned ${dirInfo.children?.length ?? 0} items`);
+    // Print results
+    console.log();
+    console.log(chalk.bold(`📁 ${dirInfo.name}`));
+    console.log(`   Total size: ${chalk.yellow(formatSize(dirInfo.size))}`);
+    console.log();
+    // Calculate maximum name width for header alignment (with reasonable limit)
+    const MAX_NAME_WIDTH = 40;
+    const maxNameLength = dirInfo.children && dirInfo.children.length > 0
+        ? Math.min(Math.max(...dirInfo.children.slice(0, limit).map((item) => item.name.length), NAME_WIDTH), MAX_NAME_WIDTH)
+        : NAME_WIDTH;
+    // Print header for aligned columns
+    const headerName = 'Name'.padEnd(maxNameLength);
+    console.log(chalk.dim(`     ${headerName}  ${'0%   20%   40%   60%   80%  100%'.padStart(BAR_WIDTH + 2)}       Size   Ratio`));
+    console.log();
+    if (dirInfo.children && dirInfo.children.length > 0) {
+        const maxSize = dirInfo.children[0]?.size ?? 1;
+        printTree(dirInfo.children, maxSize, limit);
+    }
+    else {
+        warning('No items found in directory');
+    }
+    // Show common large directories
+    console.log();
+    separator();
+    console.log();
+    console.log(chalk.bold('💡 Quick Analysis:'));
+    console.log();
+    // Header for Quick Analysis with scale
+    console.log(chalk.dim('  Location         0%   20%   40%   60%   80%  100%      Size'));
+    console.log();
+    const quickPaths = [
+        { path: '~/Library/Caches', label: 'User Caches' },
+        { path: '~/Library/Application Support', label: 'App Support' },
+        { path: '~/.Trash', label: 'Trash' },
+        { path: '~/Downloads', label: 'Downloads' },
+        { path: '~/Library/Developer', label: 'Developer Data' },
+    ];
+    const quickResults = [];
+    for (const item of quickPaths) {
+        const fullPath = expandPath(item.path);
+        if (exists(fullPath)) {
+            const size = await getSize(fullPath);
+            quickResults.push({ label: item.label, size });
+        }
+    }
+    // Sort by size
+    quickResults.sort((a, b) => b.size - a.size);
+    const maxQuickSize = quickResults[0]?.size ?? 1;
+    for (const result of quickResults) {
+        const bar = generateQuickAnalysisBar(result.size, maxQuickSize, 30);
+        const sizeStr = formatSize(result.size).padStart(10);
+        console.log(`  ${result.label.padEnd(15)} ${bar} ${chalk.cyan(sizeStr)}`);
+    }
+    // Recommendations
+    console.log();
+    console.log(chalk.bold('📋 Recommendations:'));
+    const totalQuickSize = quickResults.reduce((sum, r) => sum + r.size, 0);
+    if (totalQuickSize > 5 * 1024 * 1024 * 1024) {
+        // > 5GB
+        console.log(chalk.yellow(`  ⚠️  You have ${formatSize(totalQuickSize)} in common cleanup locations`));
+        console.log(chalk.dim('     Run "broom clean" to free up space'));
+    }
+    else {
+        console.log(chalk.green('  ✓ Your disk looks reasonably clean'));
+    }
+    console.log();
+    console.log(chalk.dim('Tip: Use "broom analyze --path /path/to/dir" to analyze a specific directory'));
+    console.log(chalk.dim('     Use "broom analyze --depth 2" to scan deeper'));
+}
+/**
+ * Create analyze command
+ */
+export function createAnalyzeCommand() {
+    const cmd = new Command('analyze')
+        .description('Analyze disk space usage')
+        .option('-p, --path <path>', 'Path to analyze (default: home directory)')
+        .option('-d, --depth <number>', 'Scan depth (default: 1)', parseInt)
+        .option('-l, --limit <number>', 'Max items to show (default: 15)', parseInt)
+        .action(async (options) => {
+        await analyzeCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/backup.js

@@ -0,0 +1,257 @@
+/**
+ * Backup/Restore command - Safe file deletion with backup
+ */
+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, info } from '../ui/output.js';
+import { mkdir, readFile, writeFile, unlink, stat } from 'fs/promises';
+import { join } from 'path';
+import { execSync } from 'child_process';
+const BACKUP_DIR = expandPath('~/.config/broom/backups');
+const METADATA_FILE = expandPath('~/.config/broom/backups/metadata.json');
+const DEFAULT_RETENTION_DAYS = 7;
+/**
+ * Load backup metadata
+ */
+async function loadMetadata() {
+    const metadataMap = new Map();
+    try {
+        if (exists(METADATA_FILE)) {
+            const content = await readFile(METADATA_FILE, 'utf-8');
+            const data = JSON.parse(content);
+            for (const [id, meta] of Object.entries(data)) {
+                metadataMap.set(id, {
+                    ...meta,
+                    timestamp: new Date(meta.timestamp),
+                    expiresAt: new Date(meta.expiresAt),
+                });
+            }
+        }
+    }
+    catch {
+        // Return empty map if cannot read
+    }
+    return metadataMap;
+}
+/**
+ * Save backup metadata
+ */
+async function saveMetadata(metadataMap) {
+    const data = {};
+    for (const [id, meta] of metadataMap.entries()) {
+        data[id] = meta;
+    }
+    await mkdir(join(BACKUP_DIR, '..'), { recursive: true });
+    await writeFile(METADATA_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+/**
+ * Create a backup
+ */
+export async function createBackup(filePaths, description = 'Manual backup') {
+    const backupId = `backup-${Date.now()}`;
+    const backupPath = join(BACKUP_DIR, `${backupId}.tar.gz`);
+    // Ensure backup directory exists
+    await mkdir(BACKUP_DIR, { recursive: true });
+    // Create tar.gz archive
+    const filesList = filePaths.map((p) => `"${p}"`).join(' ');
+    try {
+        execSync(`tar -czf "${backupPath}" ${filesList} 2>/dev/null`, {
+            cwd: expandPath('~'),
+        });
+    }
+    catch (err) {
+        throw new Error(`Failed to create backup: ${err}`);
+    }
+    // Calculate backup size
+    const stats = await stat(backupPath);
+    const totalSize = stats.size;
+    // Save metadata
+    const metadata = {
+        id: backupId,
+        timestamp: new Date(),
+        files: filePaths,
+        totalSize,
+        expiresAt: new Date(Date.now() + DEFAULT_RETENTION_DAYS * 24 * 60 * 60 * 1000),
+        description,
+    };
+    const metadataMap = await loadMetadata();
+    metadataMap.set(backupId, metadata);
+    await saveMetadata(metadataMap);
+    return backupId;
+}
+/**
+ * List backups
+ */
+async function listBackups() {
+    printHeader('📦 Backup List');
+    const metadataMap = await loadMetadata();
+    if (metadataMap.size === 0) {
+        warning('No backups found');
+        return;
+    }
+    // Sort by timestamp (newest first)
+    const backups = Array.from(metadataMap.values()).sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    console.log();
+    for (const backup of backups) {
+        const isExpired = new Date() > backup.expiresAt;
+        const age = Math.floor((Date.now() - backup.timestamp.getTime()) / (1000 * 60 * 60 * 24));
+        console.log(chalk.bold(`ID: ${backup.id}`));
+        console.log(`  Description: ${backup.description}`);
+        console.log(`  Created: ${backup.timestamp.toLocaleString()} (${age} days ago)`);
+        console.log(`  Size: ${formatSize(backup.totalSize)}`);
+        console.log(`  Files: ${backup.files.length}`);
+        if (isExpired) {
+            console.log(chalk.red('  Status: Expired'));
+        }
+        else {
+            const daysLeft = Math.floor((backup.expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+            console.log(chalk.green(`  Status: Active (${daysLeft} days left)`));
+        }
+        console.log();
+    }
+    separator();
+    console.log();
+    console.log(chalk.dim('Use "broom restore <backup-id>" to restore a backup'));
+    console.log(chalk.dim('Use "broom backup --clean" to remove expired backups'));
+}
+/**
+ * Clean expired backups
+ */
+async function cleanExpiredBackups() {
+    printHeader('🧹 Cleaning Expired Backups');
+    const metadataMap = await loadMetadata();
+    const now = new Date();
+    let removedCount = 0;
+    let freedSpace = 0;
+    for (const [id, meta] of metadataMap.entries()) {
+        if (now > meta.expiresAt) {
+            const backupPath = join(BACKUP_DIR, `${id}.tar.gz`);
+            if (exists(backupPath)) {
+                const stats = await stat(backupPath);
+                freedSpace += stats.size;
+                await unlink(backupPath);
+                metadataMap.delete(id);
+                removedCount++;
+                console.log(chalk.dim(`Removed: ${id} (${formatSize(stats.size)})`));
+            }
+        }
+    }
+    await saveMetadata(metadataMap);
+    console.log();
+    if (removedCount > 0) {
+        success(`Removed ${removedCount} expired backup(s), freed ${formatSize(freedSpace)}`);
+    }
+    else {
+        info('No expired backups to remove');
+    }
+}
+/**
+ * Restore a backup
+ */
+async function restoreBackup(backupId) {
+    printHeader(`📦 Restoring Backup: ${backupId}`);
+    const metadataMap = await loadMetadata();
+    const metadata = metadataMap.get(backupId);
+    if (!metadata) {
+        error(`Backup not found: ${backupId}`);
+        return;
+    }
+    const backupPath = join(BACKUP_DIR, `${backupId}.tar.gz`);
+    if (!exists(backupPath)) {
+        error(`Backup file not found: ${backupPath}`);
+        return;
+    }
+    console.log();
+    console.log(chalk.bold('Backup Information:'));
+    console.log(`  Created: ${metadata.timestamp.toLocaleString()}`);
+    console.log(`  Files: ${metadata.files.length}`);
+    console.log(`  Size: ${formatSize(metadata.totalSize)}`);
+    console.log();
+    // Ask for confirmation
+    const { confirm } = await import('../ui/prompts.js');
+    const shouldRestore = await confirm({ message: 'Restore this backup?' });
+    if (!shouldRestore) {
+        warning('Restore cancelled');
+        return;
+    }
+    console.log();
+    info('Restoring files...');
+    try {
+        // Extract to home directory
+        execSync(`tar -xzf "${backupPath}" -C "${expandPath('~')}"`, {
+            stdio: 'inherit',
+        });
+        success('Backup restored successfully!');
+        console.log();
+        console.log(chalk.dim('Restored files:'));
+        for (const file of metadata.files) {
+            console.log(chalk.dim(`  - ${file}`));
+        }
+    }
+    catch (err) {
+        error(`Failed to restore backup: ${err}`);
+    }
+}
+/**
+ * Execute backup command
+ */
+export async function backupCommand(options) {
+    if (options.list) {
+        await listBackups();
+        return;
+    }
+    if (options.clean) {
+        await cleanExpiredBackups();
+        return;
+    }
+    // Show help
+    printHeader('📦 Backup Management');
+    console.log();
+    console.log(chalk.bold('Usage:'));
+    console.log('  broom backup --list         List all backups');
+    console.log('  broom backup --clean        Remove expired backups');
+    console.log('  broom restore <backup-id>   Restore a specific backup');
+    console.log('  broom restore --list        List restorable backups');
+    console.log();
+    console.log(chalk.dim('Backups are automatically created when using --backup flag with clean'));
+    console.log(chalk.dim(`Default retention period: ${DEFAULT_RETENTION_DAYS} days`));
+}
+/**
+ * Execute restore command
+ */
+export async function restoreCommand(options, backupId) {
+    if (options.list || !backupId) {
+        await listBackups();
+        return;
+    }
+    await restoreBackup(backupId);
+}
+/**
+ * Create backup command
+ */
+export function createBackupCommand() {
+    const cmd = new Command('backup')
+        .description('Manage file backups')
+        .option('-l, --list', 'List all backups')
+        .option('-c, --clean', 'Remove expired backups')
+        .option('-r, --retention <days>', 'Set retention period in days', parseInt)
+        .action(async (options) => {
+        await backupCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}
+/**
+ * Create restore command
+ */
+export function createRestoreCommand() {
+    const cmd = new Command('restore')
+        .description('Restore files from backup')
+        .argument('[backup-id]', 'Backup ID to restore')
+        .option('-l, --list', 'List restorable backups')
+        .action(async (backupId, options) => {
+        await restoreCommand(options, backupId);
+    });
+    return enhanceCommandHelp(cmd);
+}