@tukuyomil032/broom 1.0.1 → 1.0.5

package/dist/commands/analyze.js

@@ -3,18 +3,22 @@
  */
 import chalk from 'chalk';
 import { Command } from 'commander';
+import blessed from 'blessed';
 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';
+import { join, basename, dirname } from 'path';
+import { getSize, formatSize, expandPath } from '../utils/fs.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { createSpinner, succeedSpinner, failSpinner, } from '../ui/output.js';
+const execAsync = promisify(exec);
 // Fixed column widths for aligned display
 const NAME_WIDTH = 25;
 const BAR_WIDTH = 30;
 /**
- * Scan directory for sizes
+ * Scan directory for sizes - recursive with optional depth limit
  */
-async function scanDirectory(dirPath, depth, currentDepth = 0) {
+async function scanDirectory(dirPath, currentDepth = 0, maxDepth) {
     try {
         const stats = await stat(dirPath);
         const name = basename(dirPath) || dirPath;
@@ -24,6 +28,7 @@ async function scanDirectory(dirPath, depth, currentDepth = 0) {
                 name,
                 size: stats.size,
                 isDirectory: false,
+                mtime: stats.mtime,
             };
         }
         // Get total size
@@ -33,44 +38,57 @@ async function scanDirectory(dirPath, depth, currentDepth = 0) {
             name,
             size,
             isDirectory: true,
+            mtime: stats.mtime,
         };
-        // 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;
+        // Check depth limit
+        if (maxDepth !== undefined && currentDepth >= maxDepth) {
+            info.children = [];
+            return info;
+        }
+        // Recursively scan subdirectories
+        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);
+                    if (childStats.isDirectory()) {
+                        // Recursively scan subdirectories
+                        const childInfo = await scanDirectory(childPath, currentDepth + 1, maxDepth);
+                        if (childInfo) {
+                            children.push(childInfo);
+                        }
                     }
-                    try {
-                        const childStats = await stat(childPath);
-                        const childSize = childStats.isDirectory() ? await getSize(childPath) : childStats.size;
+                    else {
+                        const childSize = childStats.size;
                         children.push({
                             path: childPath,
                             name: entry,
                             size: childSize,
-                            isDirectory: childStats.isDirectory(),
+                            isDirectory: false,
                         });
                     }
-                    catch {
-                        // Skip if cannot access
-                    }
                 }
-                // Sort by size descending
-                children.sort((a, b) => b.size - a.size);
-                info.children = children;
-            }
-            catch {
-                // Cannot read directory
+                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;
     }
@@ -79,35 +97,95 @@ async function scanDirectory(dirPath, depth, currentDepth = 0) {
     }
 }
 /**
- * Generate size bar for Quick Analysis - with borders and gridlines
+ * Generate disk usage bar graph with chalk colors.
+ * Safe to use in listBox with tags:false (ANSI codes rendered by terminal directly).
  */
-function generateQuickAnalysisBar(size, maxSize, width = 20) {
-    const percentage = maxSize > 0 ? size / maxSize : 0;
-    const filledWidth = Math.round(percentage * width);
+function generateUsageBar(size, parentSize, width = 20) {
+    const percentage = parentSize > 0 ? size / parentSize : 0;
+    const clamped = Math.min(percentage, 1);
+    const filledWidth = Math.round(clamped * 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;
+    for (let i = 0; i < width; i++) {
+        if (i < filledWidth) {
+            const ratio = i / width;
+            if (ratio < 0.5) {
+                bar += chalk.green('█');
+            }
+            else if (ratio < 0.75) {
+                bar += chalk.yellow('█');
+            }
+            else {
+                bar += chalk.red('█');
+            }
+        }
+        else {
+            bar += chalk.gray('░');
+        }
     }
-    // Build bar with gridlines every 20%
+    const pct = (clamped * 100).toFixed(1);
+    return `${bar} ${pct}%`;
+}
+/**
+ * Generate disk usage bar using blessed tags (for info box display)
+ */
+function generateUsageBarBlessed(size, parentSize, width = 28) {
+    const percentage = parentSize > 0 ? size / parentSize : 0;
+    const clamped = Math.min(percentage, 1);
+    const filledWidth = Math.round(clamped * width);
+    let bar = '';
     for (let i = 0; i < width; i++) {
-        const isGridline = i > 0 && i % (width / 5) === 0;
         if (i < filledWidth) {
-            bar += isGridline ? chalk.white('│') : color('█');
+            const ratio = i / width;
+            if (ratio < 0.5) {
+                bar += '{green-fg}█{/green-fg}';
+            }
+            else if (ratio < 0.75) {
+                bar += '{yellow-fg}█{/yellow-fg}';
+            }
+            else {
+                bar += '{red-fg}█{/red-fg}';
+            }
         }
         else {
-            bar += isGridline ? chalk.gray('│') : chalk.gray('░');
+            bar += '{white-fg}░{/white-fg}';
         }
     }
-    // Add horizontal borders
-    return chalk.gray('│') + bar + chalk.gray('│');
+    const pct = (clamped * 100).toFixed(1);
+    // NOTE: percentage is plain text, NOT wrapped in blessed tags
+    return `${bar} ${pct}%`;
+}
+/**
+ * Normalize path for comparison
+ */
+function normalizePath(p) {
+    return p.replace(/\/+$/, '') || '/'; // Remove trailing slashes
+}
+/**
+ * Get folder at path from DirInfo tree
+ */
+function getFolderAtPath(root, targetPath) {
+    const normalizedTarget = normalizePath(targetPath);
+    const normalizedRoot = normalizePath(root.path);
+    if (normalizedRoot === normalizedTarget) {
+        return root;
+    }
+    if (!root.children) {
+        return null;
+    }
+    for (const child of root.children) {
+        const result = getFolderAtPath(child, targetPath);
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+}
+/**
+ * Get immediate children of a folder
+ */
+function getChildrenAtPath(root, targetPath) {
+    const folder = getFolderAtPath(root, targetPath);
+    return folder?.children || [];
 }
 /**
  * Generate size bar for tree display with gridlines
@@ -210,7 +288,7 @@ function generateDiskBar(used, total, width = 40) {
 /**
  * Print directory tree with aligned columns
  */
-function printTree(items, maxSize, limit, indent = '') {
+function printTree(items, parentSize, limit, indent = '') {
     const displayed = items.slice(0, limit);
     const remaining = items.length - limit;
     // Calculate maximum name width from displayed items (with reasonable limit)
@@ -218,6 +296,8 @@ function printTree(items, maxSize, limit, indent = '') {
     const maxNameLength = Math.min(Math.max(...displayed.map((item) => item.name.length), NAME_WIDTH // Minimum width
     ), MAX_NAME_WIDTH // Maximum width
     );
+    // Find max size for bar visualization (visual reference only)
+    const maxSizeForBar = Math.max(...displayed.map((item) => item.size), 1);
     for (let i = 0; i < displayed.length; i++) {
         const item = displayed[i];
         const isLast = i === displayed.length - 1 && remaining <= 0;
@@ -233,9 +313,11 @@ function printTree(items, maxSize, limit, indent = '') {
                     displayName.substring(displayName.length - keepLength);
         }
         displayName = displayName.padEnd(maxNameLength);
-        const bar = generateTreeBar(item.size, maxSize);
+        // Use parent size as reference for bar visualization
+        const bar = generateTreeBar(item.size, parentSize);
         const sizeStr = formatSize(item.size).padStart(10);
-        const percentage = maxSize > 0 ? ((item.size / maxSize) * 100).toFixed(1).padStart(5) + '%' : '  0.0%';
+        // Calculate percentage relative to parent directory total size
+        const percentage = parentSize > 0 ? ((item.size / parentSize) * 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) {
@@ -257,103 +339,305 @@ async function getDiskUsage() {
     }
 }
 /**
- * Execute analyze command
+ * Execute analyze command with interactive UI and optimized loading
  */
 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) {
+    const rawPath = options.positionalPath || options.path;
+    const targetPath = rawPath ? expandPath(rawPath) : expandPath('~');
+    // First, show initial message in console
+    console.clear();
+    console.log(chalk.bold.cyan('\n🧹 Broom - Disk Space Analyzer\n'));
+    const spinner = createSpinner('Scanning directory structure (initial scan)...');
+    // First pass: shallow scan for quick display
+    let rootInfo = await scanDirectory(targetPath, 0, 2);
+    if (!rootInfo) {
         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');
+    succeedSpinner(spinner, 'Initial scan complete');
+    if (!rootInfo.children || rootInfo.children.length === 0) {
+        console.log(chalk.yellow('No items found in directory'));
+        return;
     }
-    // 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 });
+    // Start UI display
+    let currentPath = targetPath;
+    function displayDirectory() {
+        // Normalize current path for consistency
+        const normalizedPath = normalizePath(currentPath);
+        // Get current folder and its direct children
+        const currentFolder = getFolderAtPath(rootInfo, normalizedPath);
+        if (!currentFolder) {
+            console.log(chalk.red(`Error: Could not find folder at ${normalizedPath}. Current root: ${normalizePath(rootInfo.path)}`));
+            return;
         }
+        const items = currentFolder.children || [];
+        // Create blessed screen for interactive UI
+        const screen = blessed.screen({
+            smartCSR: true,
+            title: 'Broom - Disk Space Analyzer',
+            fullUnicode: true,
+        });
+        // Header box
+        const headerBox = blessed.box({
+            parent: screen,
+            top: 0,
+            left: 0,
+            width: '100%',
+            height: 3,
+            tags: true,
+            border: { type: 'line' },
+            style: { border: { fg: 'cyan' } },
+            content: ` {bold}📊 ${normalizedPath}{/bold}\n {dim}Total: ${formatSize(currentFolder.size)} | Items: ${items.length}{/dim}`,
+        });
+        // Main list box - folders/files in current directory
+        // tags: false to prevent ANSI codes in item text from being misinterpreted
+        const listBox = blessed.list({
+            parent: screen,
+            top: 3,
+            left: 0,
+            width: '60%',
+            height: '100%-6',
+            label: ' Contents ',
+            tags: false,
+            border: { type: 'line' },
+            style: {
+                border: { fg: 'cyan' },
+                selected: { bg: 'blue', fg: 'white', bold: true },
+            },
+            mouse: true,
+            keys: true,
+        });
+        // Info box - details of selected item
+        const infoBox = blessed.box({
+            parent: screen,
+            top: 3,
+            left: '60%',
+            width: '40%',
+            height: '100%-6',
+            label: ' {cyan-fg}↕{/cyan-fg} Details ',
+            tags: true,
+            border: { type: 'line' },
+            style: { border: { fg: 'cyan' } },
+            scrollable: true,
+            mouse: true,
+        });
+        // Footer box
+        blessed.box({
+            parent: screen,
+            bottom: 0,
+            left: 0,
+            width: '100%',
+            height: 3,
+            tags: true,
+            border: { type: 'line' },
+            style: { border: { fg: 'cyan' } },
+            content: '{cyan-fg}↑↓{/cyan-fg} Navigate | {green-fg}Enter{/green-fg} Open folder | {red-fg}o{/red-fg} Open in Finder | {yellow-fg}b{/yellow-fg} Back | {red-fg}q/Esc{/red-fg} Quit',
+        });
+        // Populate list with items (plain text only - no ANSI/tags to avoid index corruption)
+        let selectedIndex = 0;
+        items.forEach((item) => {
+            const icon = item.isDirectory ? '>' : ' ';
+            const name = item.name.substring(0, 24).padEnd(24);
+            const bar = generateUsageBar(item.size, currentFolder.size, 18);
+            listBox.addItem(`${icon} ${name} ${bar}`);
+        });
+        // Update info box when selection changes
+        const updateInfoBox = (index) => {
+            if (index >= items.length || index < 0)
+                return;
+            selectedIndex = index;
+            const selectedItem = items[index];
+            if (!selectedItem)
+                return;
+            const usageBar = generateUsageBarBlessed(selectedItem.size, currentFolder.size, 24);
+            const pct = currentFolder.size > 0
+                ? ((selectedItem.size / currentFolder.size) * 100).toFixed(1)
+                : '0.0';
+            // Rank in parent by size
+            const rank = items.indexOf(selectedItem) + 1;
+            // Children breakdown
+            const childDirs = selectedItem.children?.filter((c) => c.isDirectory).length ?? 0;
+            const childFiles = selectedItem.children?.filter((c) => !c.isDirectory).length ?? 0;
+            const hasChildren = childDirs + childFiles > 0;
+            // Last modified
+            const mtimeStr = selectedItem.mtime
+                ? selectedItem.mtime.toLocaleString('ja-JP', {
+                    year: 'numeric',
+                    month: '2-digit',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                })
+                : 'Unknown';
+            // Size comparison label
+            let sizeLabel = '';
+            if (pct !== '0.0') {
+                const p = parseFloat(pct);
+                if (p >= 30)
+                    sizeLabel = ' {red-fg}(Very large){/red-fg}';
+                else if (p >= 10)
+                    sizeLabel = ' {yellow-fg}(Large){/yellow-fg}';
+                else if (p >= 1)
+                    sizeLabel = ' {green-fg}(Medium){/green-fg}';
+                else
+                    sizeLabel = ' {cyan-fg}(Small){/cyan-fg}';
+            }
+            // Icon
+            const icon = selectedItem.isDirectory ? '📁' : '📄';
+            const typeLabel = selectedItem.isDirectory ? 'Directory' : 'File';
+            // Path - wrap at 30 chars
+            const pathParts = [];
+            let remaining = selectedItem.path;
+            while (remaining.length > 30) {
+                pathParts.push(remaining.slice(0, 30));
+                remaining = remaining.slice(30);
+            }
+            pathParts.push(remaining);
+            const wrappedPath = pathParts.join('\n  ');
+            const divider = '{cyan-fg}' + '─'.repeat(28) + '{/cyan-fg}';
+            const infoText = 
+            // Title
+            `${icon} {bold}{underline}${selectedItem.name}{/underline}{/bold}\n` +
+                `${divider}\n\n` +
+                // Usage
+                `{yellow-fg}📊 Usage{/yellow-fg}\n` +
+                `  ${usageBar}\n` +
+                `  {bold}${pct}%{/bold} of parent${sizeLabel}\n\n` +
+                // Rank
+                `{yellow-fg}🏆 Rank{/yellow-fg}\n` +
+                `  {bold}#${rank}{/bold} of ${items.length} items\n\n` +
+                // Size
+                `{yellow-fg}💾 Size{/yellow-fg}\n` +
+                `  {bold}${formatSize(selectedItem.size)}{/bold}\n\n` +
+                // Type
+                `{yellow-fg}📂 Type{/yellow-fg}\n` +
+                `  ${typeLabel}\n\n` +
+                // Contents (directories only)
+                (selectedItem.isDirectory
+                    ? `{yellow-fg}📋 Contents{/yellow-fg}\n` +
+                        (hasChildren
+                            ? `  {green-fg}${childDirs} folders{/green-fg}, {cyan-fg}${childFiles} files{/cyan-fg}\n\n`
+                            : `  {gray-fg}(Enter to scan){/gray-fg}\n\n`)
+                    : '') +
+                // Last modified
+                `{yellow-fg}🕐 Modified{/yellow-fg}\n` +
+                `  ${mtimeStr}\n\n` +
+                // Path
+                `{yellow-fg}📍 Path{/yellow-fg}\n` +
+                `  {gray-fg}${wrappedPath}{/gray-fg}\n\n` +
+                `${divider}\n` +
+                // Actions
+                `{yellow-fg}⌨️  Actions{/yellow-fg}\n` +
+                (selectedItem.isDirectory ? `  {green-fg}[Enter]{/green-fg} Open folder\n` : '') +
+                `  {magenta-fg}[o]{/magenta-fg} Open in Finder\n` +
+                (normalizedPath !== normalizePath(targetPath) ? `  {cyan-fg}[b]{/cyan-fg} Go back\n` : '') +
+                `  {red-fg}[q]{/red-fg} Quit`;
+            infoBox.setContent(infoText);
+            screen.render();
+        };
+        // 'select item' fires on arrow key navigation in blessed List
+        // 'select' fires only on Enter - so use 'select item' for live updates
+        listBox.on('select item', (_item, index) => {
+            updateInfoBox(index);
+        });
+        // Open folder (navigate into it)
+        const openFolder = async () => {
+            const selectedItem = items[selectedIndex];
+            if (selectedItem && selectedItem.isDirectory) {
+                currentPath = selectedItem.path;
+                screen.destroy();
+                // If folder children are empty (not yet scanned due to shallow initial scan),
+                // scan this specific folder on-demand
+                if (!selectedItem.children || selectedItem.children.length === 0) {
+                    const subSpinner = createSpinner(`Scanning ${selectedItem.name}...`);
+                    const scanned = await scanDirectory(selectedItem.path, 0, 2);
+                    if (scanned?.children && scanned.children.length > 0) {
+                        selectedItem.children = scanned.children;
+                        selectedItem.size = scanned.size;
+                    }
+                    succeedSpinner(subSpinner, `Scanned ${selectedItem.name}`);
+                }
+                displayDirectory();
+            }
+        };
+        // Open in Finder - keep screen, show result in info box
+        const openInFinder = async () => {
+            const selectedItem = items[selectedIndex];
+            if (selectedItem) {
+                try {
+                    await execAsync(`open "${selectedItem.path}"`);
+                    infoBox.setContent(infoBox.content + '\n\n{green-fg}✓ Opened in Finder{/green-fg}');
+                }
+                catch (err) {
+                    infoBox.setContent(infoBox.content + '\n\n{red-fg}✗ Failed to open{/red-fg}');
+                }
+                screen.render();
+            }
+        };
+        // Go back to parent directory (never navigate above scan root)
+        const goBack = () => {
+            const normalizedPath = normalizePath(currentPath);
+            const normalizedTarget = normalizePath(targetPath);
+            // Already at scan root - do nothing
+            if (normalizedPath === normalizedTarget) {
+                return;
+            }
+            const parent = dirname(normalizedPath);
+            if (parent !== normalizedPath) {
+                currentPath = parent;
+                screen.destroy();
+                displayDirectory();
+            }
+        };
+        // Keyboard handlers
+        listBox.key(['enter'], () => {
+            void openFolder();
+        });
+        listBox.key(['o'], () => {
+            void openInFinder();
+        });
+        listBox.key(['b'], () => {
+            goBack();
+        });
+        listBox.key(['q', 'escape', 'C-c'], () => {
+            screen.destroy();
+            process.exit(0);
+        });
+        // Mouse double-click to open folder
+        let lastClickTime = 0;
+        listBox.on('click', () => {
+            const selectedItem = items[selectedIndex];
+            if (selectedItem?.isDirectory) {
+                const now = Date.now();
+                if (now - lastClickTime < 300) {
+                    void openFolder();
+                }
+                lastClickTime = now;
+            }
+        });
+        // Focus on list initially
+        listBox.focus();
+        // Set initial selection
+        if (items.length > 0) {
+            listBox.select(0);
+            updateInfoBox(0);
+        }
+        // Render the screen
+        screen.render();
     }
-    // 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'));
+    displayDirectory();
+    // Background: Continue deeper scan to fill in missing data
+    setImmediate(async () => {
+        try {
+            const fullInfo = await scanDirectory(targetPath);
+            if (fullInfo) {
+                rootInfo = fullInfo;
+            }
+        }
+        catch {
+            // Silently fail - user can still use shallow scan
+        }
+    });
 }
 /**
  * Create analyze command
@@ -361,11 +645,10 @@ export async function analyzeCommand(options) {
 export function createAnalyzeCommand() {
     const cmd = new Command('analyze')
         .description('Analyze disk space usage')
+        .argument('[path]', 'Path to analyze (default: home directory)')
         .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);
+        .action(async (positionalPath, options) => {
+        await analyzeCommand({ ...options, positionalPath });
     });
     return enhanceCommandHelp(cmd);
 }

package/dist/commands/clean.js

@@ -60,14 +60,35 @@ export async function cleanCommand(options) {
     // Scan phase
     const scanners = getAllScanners();
     const progress = createProgress(scanners.length);
-    console.log(chalk.cyan('Scanning for cleanable files...\n'));
+    // Display scan targets
+    console.log(chalk.bold('\n📍 Scan Targets:'));
+    console.log(chalk.dim('The following locations will be scanned:\n'));
+    const scanTargets = [
+        { icon: '📁', name: 'User Caches', path: '~/Library/Caches' },
+        { icon: '📋', name: 'User Logs', path: '~/Library/Logs' },
+        { icon: '🗑', name: 'Trash', path: '~/.Trash' },
+        { icon: '🌐', name: 'Browser Caches', path: '~/Library/**/Cache' },
+        { icon: '📦', name: 'Development Caches', path: 'Various dev tool caches' },
+        { icon: '🛠', name: 'Xcode Caches', path: '~/Library/Developer' },
+        { icon: '⬇️', name: 'Old Downloads', path: '~/Downloads' },
+        { icon: '🍺', name: 'Homebrew Caches', path: '/Library/Caches/Homebrew' },
+        { icon: '🐳', name: 'Docker Artifacts', path: '~/.docker' },
+        { icon: '📱', name: 'iOS Backups', path: '~/Library/Caches/com.apple.bird*' },
+        { icon: '❄️', name: 'Temporary Files', path: '/var/tmp, /tmp' },
+        { icon: '🔗', name: 'Node Modules', path: 'Large node_modules directories' },
+        { icon: '🔧', name: 'Old Installers', path: 'Failed/old installer files' },
+    ];
+    for (const target of scanTargets) {
+        console.log(`  ${target.icon} ${target.name.padEnd(25)} ${chalk.dim(target.path)}`);
+    }
+    console.log(chalk.cyan('\nScanning for cleanable files...\n'));
     debug(`Starting scan with ${scanners.length} scanners`);
     const summary = await runAllScans({
         parallel: true,
         concurrency: 4,
         onProgress: (completed, total, scanner) => {
             debug(`Scan progress: ${completed}/${total} - ${scanner.category.name}`);
-            progress.update(completed, `Scanning ${scanner.category.name}...`);
+            progress.update(completed, `Scanning ${scanner.category.name}... (${completed}/${total})`);
         },
     });
     progress.finish('Scan complete');

package/dist/commands/status.js

@@ -8,147 +8,6 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { enhanceCommandHelp } from '../utils/help.js';
 const execAsync = promisify(exec);
-// Broom character ASCII art animation frames (like mole's cat)
-const BROOM_FRAMES = [
-    // Frame 0: Idle
-    `
-    ╭─────────────────╮
-    │    ╭───────╮    │
-    │    │ ◕  ◕ │    │
-    │    │  ───  │    │
-    │    ╰───────╯    │
-    │    ╭───────╮    │
-    │   /│ BROOM │\\   │
-    │  / ╰───────╯ \\  │
-    │ /   |||||||   \\ │
-    │     |||||||     │
-    ╰─────────────────╯
-  `,
-    // Frame 1: Sweeping right
-    `
-    ╭─────────────────╮
-    │    ╭───────╮    │
-    │    │ ◕  ◕ │    │
-    │    │  ───  │░░░ │
-    │    ╰───────╯░░░ │
-    │    ╭───────╮░░  │
-    │   /│ BROOM │\\   │
-    │  / ╰───────╯ \\  │
-    │    /|||||||\\    │
-    │     |||||||     │
-    ╰─────────────────╯
-  `,
-    // Frame 2: Sweeping
-    `
-    ╭─────────────────╮
-    │    ╭───────╮    │
-    │    │ ◕ᴗ◕  │    │
-    │ ░░ │  ~~~  │    │
-    │░░░ ╰───────╯    │
-    │░░  ╭───────╮    │
-    │   /│ BROOM │\\   │
-    │  / ╰───────╯ \\  │
-    │   / ||||||| \\   │
-    │     |||||||     │
-    ╰─────────────────╯
-  `,
-    // Frame 3: Dust cloud
-    `
-    ╭─────────────────╮
-    │    ╭───────╮ ·  │
-    │ ·  │ ^  ^  │  · │
-    │  · │  ◡◡  │ ·  │
-    │ · ·╰───────╯· · │
-    │  · ╭───────╮ ·  │
-    │   /│ BROOM │\\   │
-    │  / ╰───────╯ \\  │
-    │    /|||||||\\    │
-    │     |||||||     │
-    ╰─────────────────╯
-  `,
-    // Frame 4: Sparkle clean
-    `
-    ╭─────────────────╮
-    │    ╭───────╮ ✨ │
-    │ ✨ │ ✧  ✧ │    │
-    │    │  ◡◡◡ │ ✨ │
-    │    ╰───────╯    │
-    │ ✨ ╭───────╮    │
-    │   /│ CLEAN │\\   │
-    │  / ╰───────╯ \\ ✨│
-    │    /|||||||\\    │
-    │     |||||||     │
-    ╰─────────────────╯
-  `,
-];
-// Simpler frames for better compatibility
-const BROOM_SIMPLE_FRAMES = [
-    // Frame 0: Idle
-    [
-        '   ╭─────────╮   ',
-        '   │  ◕  ◕  │   ',
-        '   │   ──   │   ',
-        '   ╰────┬───╯   ',
-        '   ╭────┴───╮   ',
-        '   │ BROOM  │   ',
-        '   ╰────────╯   ',
-        '       ▓▓       ',
-        '      ▓▓▓▓      ',
-        '     ▓▓▓▓▓▓     ',
-    ],
-    // Frame 1: Sweeping right
-    [
-        '   ╭─────────╮   ',
-        '   │  ◕  ◕  │ ░ ',
-        '   │   ──   │░░░',
-        '   ╰────┬───╯ ░░',
-        '   ╭────┴───╮ ░ ',
-        '   │ BROOM  │   ',
-        '   ╰────────╯   ',
-        '       ▓▓       ',
-        '      ▓▓▓▓\\     ',
-        '     ▓▓▓▓▓▓\\    ',
-    ],
-    // Frame 2: Sweeping left
-    [
-        '   ╭─────────╮   ',
-        ' ░ │  ◕ᴗ◕  │   ',
-        '░░░│   ~~   │   ',
-        '░░ ╰────┬───╯   ',
-        ' ░ ╭────┴───╮   ',
-        '   │ BROOM  │   ',
-        '   ╰────────╯   ',
-        '       ▓▓       ',
-        '     /▓▓▓▓      ',
-        '    /▓▓▓▓▓▓     ',
-    ],
-    // Frame 3: Dust cloud
-    [
-        '   ╭─────────╮ · ',
-        ' · │  ^  ^  │ · ',
-        '  ·│   ◡◡  │·  ',
-        ' · ╰────┬───╯ · ',
-        '  ·╭────┴───╮·  ',
-        '   │ BROOM  │   ',
-        '   ╰────────╯   ',
-        '       ▓▓       ',
-        '      ▓▓▓▓      ',
-        '     ▓▓▓▓▓▓     ',
-    ],
-    // Frame 4: Sparkle
-    [
-        '   ╭─────────╮ ✨',
-        ' ✨│  ✧  ✧  │   ',
-        '   │  ◡◡◡  │ ✨',
-        '   ╰────┬───╯   ',
-        ' ✨╭────┴───╮   ',
-        '   │ CLEAN! │ ✨',
-        '   ╰────────╯   ',
-        '       ▓▓       ',
-        '      ▓▓▓▓      ',
-        '     ▓▓▓▓▓▓     ',
-    ],
-];
 /**
  * Format bytes to human readable
  */
@@ -239,43 +98,29 @@ function calculateHealth(cpuUsage, memUsage, diskUsage, batteryPercent) {
  */
 export async function statusCommand(options) {
     const interval = (options.interval ?? 2) * 1000;
-    const showBroom = options.broom !== false;
-    let broomFrame = 0;
     // Create blessed screen
     const screen = blessed.screen({
         smartCSR: true,
         title: 'Broom System Status',
         fullUnicode: true,
     });
-    // Animation box at top
-    const animBox = blessed.box({
-        parent: screen,
-        top: 0,
-        left: 'center',
-        width: 25,
-        height: showBroom ? 12 : 0,
-        tags: true,
-        style: { fg: 'cyan' },
-    });
     // Header
     const headerBox = blessed.box({
         parent: screen,
-        top: showBroom ? 12 : 0,
+        top: 0,
         left: 0,
         width: '100%',
-        height: 3,
+        height: 2,
         tags: true,
-        border: { type: 'line' },
-        style: { border: { fg: 'cyan' } },
-        label: ' {bold}🧹 Broom System Status{/bold} ',
+        style: { fg: 'cyan' },
     });
     // CPU Box
     const cpuBox = blessed.box({
         parent: screen,
-        top: showBroom ? 15 : 3,
+        top: 2,
         left: 0,
-        width: '50%-1',
-        height: 10,
+        width: '33%-1',
+        height: 8,
         label: ' {yellow-fg}●{/yellow-fg} CPU ',
         tags: true,
         border: { type: 'line' },
@@ -284,10 +129,10 @@ export async function statusCommand(options) {
     // Memory Box
     const memBox = blessed.box({
         parent: screen,
-        top: showBroom ? 15 : 3,
-        left: '50%',
-        width: '50%',
-        height: 10,
+        top: 2,
+        left: '33%',
+        width: '34%-1',
+        height: 8,
         label: ' {red-fg}▣{/red-fg} Memory ',
         tags: true,
         border: { type: 'line' },
@@ -296,10 +141,10 @@ export async function statusCommand(options) {
     // Disk Box
     const diskBox = blessed.box({
         parent: screen,
-        top: showBroom ? 25 : 13,
-        left: 0,
-        width: '50%-1',
-        height: 6,
+        top: 2,
+        left: '67%-1',
+        width: '33%',
+        height: 8,
         label: ' {blue-fg}▣{/blue-fg} Disk ',
         tags: true,
         border: { type: 'line' },
@@ -308,9 +153,9 @@ export async function statusCommand(options) {
     // Network Box
     const netBox = blessed.box({
         parent: screen,
-        top: showBroom ? 25 : 13,
-        left: '50%',
-        width: '50%',
+        top: 10,
+        left: 0,
+        width: '50%-1',
         height: 6,
         label: ' {cyan-fg}↕{/cyan-fg} Network ',
         tags: true,
@@ -320,10 +165,10 @@ export async function statusCommand(options) {
     // Processes Box
     const procBox = blessed.box({
         parent: screen,
-        top: showBroom ? 31 : 19,
-        left: 0,
-        width: '100%',
-        height: 9,
+        top: 10,
+        left: '50%',
+        width: '50%',
+        height: 6,
         label: ' {magenta-fg}●{/magenta-fg} Top Processes ',
         tags: true,
         border: { type: 'line' },
@@ -344,16 +189,6 @@ export async function statusCommand(options) {
     screen.key(['escape', 'q', 'C-c'], () => {
         process.exit(0);
     });
-    /**
-     * Update animation
-     */
-    function updateAnimation() {
-        if (!showBroom)
-            return;
-        const frame = BROOM_SIMPLE_FRAMES[broomFrame % BROOM_SIMPLE_FRAMES.length];
-        animBox.setContent('{cyan-fg}' + frame.join('\n') + '{/cyan-fg}');
-        broomFrame++;
-    }
     /**
      * Update all data
      */
@@ -383,51 +218,52 @@ export async function statusCommand(options) {
             // Header content
             const gpu = graphics.controllers?.[0];
             const gpuName = gpu?.model ? `(${gpu.model.replace('Apple ', '').split(' ')[0]})` : '';
-            const headerContent = `  {bold}Health:{/bold} {${health > 70 ? 'green' : health > 40 ? 'yellow' : 'red'}-fg}${health}%{/} | ` +
-                `{bold}Host:{/bold} ${osInfo.hostname.split('.')[0]} | ` +
-                `{bold}CPU:{/bold} ${cpuInfo.manufacturer} ${cpuInfo.brand} ${gpuName}`;
+            const headerContent = `{bold}🧹 Broom System Status{/bold}\n` +
+                `Health: {${health > 70 ? 'green' : health > 40 ? 'yellow' : 'red'}-fg}${health}%{/} | ` +
+                `Host: {cyan-fg}${osInfo.hostname.split('.')[0]}{/} | ` +
+                `CPU: ${cpuInfo.manufacturer} ${cpuInfo.brand} ${gpuName}`;
             headerBox.setContent(headerContent);
             // CPU content
             const cpuCores = cpuLoad.cpus || [];
             let cpuContent = '';
-            const coresToShow = cpuCores.slice(0, 6);
+            const coresToShow = cpuCores.slice(0, 4);
             coresToShow.forEach((core, i) => {
-                const bar = createColoredBar(core.load, 15);
+                const bar = createColoredBar(core.load, 12);
                 cpuContent += ` Core${(i + 1).toString().padStart(2)} ${bar} ${core.load.toFixed(1).padStart(5)}%\n`;
             });
             const temp = cpuTemp.main > 0 ? ` @ ${cpuTemp.main.toFixed(0)}°C` : '';
-            cpuContent += `\n {gray-fg}Load: ${cpuLoad.currentLoad.toFixed(1)}%${temp}{/gray-fg}`;
+            cpuContent += `\n{gray-fg}Load: ${cpuLoad.currentLoad.toFixed(1)}%${temp}{/gray-fg}`;
             cpuBox.setContent(cpuContent);
             // Memory content
             const memUsedPercent = (mem.used / mem.total) * 100;
             const memFreePercent = (mem.free / mem.total) * 100;
             const swapUsedPercent = mem.swaptotal > 0 ? (mem.swapused / mem.swaptotal) * 100 : 0;
             let memContent = '';
-            memContent += ` Used    ${createColoredBar(memUsedPercent, 15)} ${memUsedPercent.toFixed(1).padStart(5)}%\n`;
-            memContent += ` Free    ${createColoredBar(100 - memFreePercent, 15)} ${memFreePercent.toFixed(1).padStart(5)}%\n`;
-            memContent += ` Swap    ${createColoredBar(swapUsedPercent, 15)} ${swapUsedPercent.toFixed(1).padStart(5)}%\n`;
-            memContent += `\n {gray-fg}Total: ${formatBytes(mem.total)} | Avail: ${formatBytes(mem.available)}{/gray-fg}`;
+            memContent += ` Used    ${createColoredBar(memUsedPercent, 12)} ${memUsedPercent.toFixed(1).padStart(5)}%\n`;
+            memContent += ` Free    ${createColoredBar(100 - memFreePercent, 12)} ${memFreePercent.toFixed(1).padStart(5)}%\n`;
+            memContent += ` Swap    ${createColoredBar(swapUsedPercent, 12)} ${swapUsedPercent.toFixed(1).padStart(5)}%\n`;
+            memContent += `\n{gray-fg}Total: ${formatBytes(mem.total)}{/gray-fg}`;
             memBox.setContent(memContent);
             // Disk content
-            const diskBar = createColoredBar(diskUsage, 20);
+            const diskBar = createColoredBar(diskUsage, 15);
             let diskContent = '';
             diskContent += ` Usage   ${diskBar} ${diskUsage.toFixed(1).padStart(5)}%\n`;
-            diskContent += ` {gray-fg}Used: ${formatBytes(mainDisk?.used ?? 0)} / ${formatBytes(mainDisk?.size ?? 0)}{/gray-fg}\n`;
+            diskContent += ` {gray-fg}Used: ${formatBytes(mainDisk?.used ?? 0)}{/gray-fg}\n`;
             diskContent += ` {gray-fg}Free: ${formatBytes((mainDisk?.size ?? 0) - (mainDisk?.used ?? 0))}{/gray-fg}`;
             diskBox.setContent(diskContent);
             // Network content
             const rxSpeed = activeNet?.rx_sec ?? 0;
             const txSpeed = activeNet?.tx_sec ?? 0;
             let netContent = '';
-            netContent += ` {green-fg}↓{/green-fg} Download: ${formatSpeed(rxSpeed).padStart(12)}\n`;
-            netContent += ` {red-fg}↑{/red-fg} Upload:   ${formatSpeed(txSpeed).padStart(12)}\n`;
+            netContent += ` {green-fg}↓{/green-fg} ${formatSpeed(rxSpeed).padStart(12)}\n`;
+            netContent += ` {red-fg}↑{/red-fg} ${formatSpeed(txSpeed).padStart(12)}\n`;
             netContent += ` {gray-fg}IP: ${localIP}{/gray-fg}`;
             netBox.setContent(netContent);
             // Processes content
             let procContent = '';
-            topProcs.slice(0, 6).forEach((proc, i) => {
-                const bar = createColoredBar(Math.min(proc.cpu, 100), 10);
-                procContent += ` ${(i + 1).toString().padStart(2)}. ${proc.name.padEnd(20)} ${bar} ${proc.cpu.toFixed(1).padStart(5)}%\n`;
+            topProcs.slice(0, 4).forEach((proc, i) => {
+                const bar = createColoredBar(Math.min(proc.cpu, 100), 8);
+                procContent += ` ${(i + 1).toString().padStart(2)}. ${proc.name.padEnd(18)} ${bar} ${proc.cpu.toFixed(1).padStart(5)}%\n`;
             });
             procBox.setContent(procContent);
             screen.render();
@@ -437,19 +273,12 @@ export async function statusCommand(options) {
         }
     }
     // Initial update
-    updateAnimation();
     await update();
     // Set interval for updates
     const updateInterval = setInterval(update, interval);
-    // Animation interval (faster for smoother animation)
-    const animInterval = setInterval(() => {
-        updateAnimation();
-        screen.render();
-    }, 500);
     // Cleanup on exit
     screen.on('destroy', () => {
         clearInterval(updateInterval);
-        clearInterval(animInterval);
     });
     screen.render();
 }
@@ -460,7 +289,6 @@ export function createStatusCommand() {
     const cmd = new Command('status')
         .description('Real-time system monitoring dashboard')
         .option('-i, --interval <seconds>', 'Update interval in seconds (default: 2)', parseInt)
-        .option('--no-broom', 'Disable broom animation')
         .action(async (options) => {
         await statusCommand(options);
     });

package/dist/index.js

@@ -10,7 +10,7 @@ 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.1';
+const VERSION = '1.0.5';
 // ASCII art logo
 const logo = chalk.cyan(`
   ██████╗ ██████╗  ██████╗  ██████╗ ███╗   ███╗
@@ -49,14 +49,15 @@ ${chalk.bold('Commands:')}
   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
+  ${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 analyze --path ~/Library Analyze a Library
+  ${chalk.dim('$')} broom status --watch           Live system monitoring
+  ${chalk.dim('$')} broom purge                    Clean project artifacts
 
 ${getGlobalOptionsTable()}
 `;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tukuyomil032/broom",
   "private": false,
-  "version": "1.0.1",
+  "version": "1.0.5",
   "description": "🧹 macOS Disk Cleanup CLI - Clean up caches, logs, trash, browser data, dev artifacts, and more",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,6 +44,12 @@
     "url": "https://github.com/tukuyomil032/broom/issues"
   },
   "homepage": "https://github.com/tukuyomil032/broom#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "darwin"
+  ],
   "dependencies": {
     "@inquirer/prompts": "^8.2.0",
     "@types/handlebars": "^4.1.0",
@@ -61,7 +67,6 @@
     "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "@eslint/json": "^0.14.0",
     "@types/blessed": "^0.1.27",
     "@types/node": "^25.0.10",
     "@typescript-eslint/eslint-plugin": "^8.53.1",
@@ -82,6 +87,5 @@
       "eslint --fix",
       "prettier --write"
     ]
-  },
-  "packageManager": "bun@1.3.6"
+  }
 }