oh-my-node-modules 1.0.0

package/dist/cli.js

@@ -0,0 +1,1674 @@
+import { Box, Text, useInput, useStdout, useApp, render } from 'ink';
+import React, { useState, useMemo, useEffect, useCallback } from 'react';
+import { promises } from 'fs';
+import { join, basename, dirname } from 'path';
+
+/** 
+ * Header displays the app title and overall statistics.
+ * Shows scanning progress when active.
+ */ const Header = ({ statistics, isScanning, scanProgress })=>{
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        borderStyle: "single",
+        padding: 1
+    }, /*#__PURE__*/ React.createElement(Box, {
+        justifyContent: "space-between"
+    }, /*#__PURE__*/ React.createElement(Text, {
+        bold: true,
+        color: "cyan"
+    }, "oh-my-node-modules"), isScanning && /*#__PURE__*/ React.createElement(Text, {
+        color: "yellow"
+    }, "Scanning... ", scanProgress, "%")), /*#__PURE__*/ React.createElement(Box, {
+        justifyContent: "space-between",
+        marginTop: 1
+    }, /*#__PURE__*/ React.createElement(Text, null, /*#__PURE__*/ React.createElement(Text, {
+        color: "white"
+    }, "Projects: "), /*#__PURE__*/ React.createElement(Text, {
+        bold: true,
+        color: "green"
+    }, statistics.totalProjects)), /*#__PURE__*/ React.createElement(Text, null, /*#__PURE__*/ React.createElement(Text, {
+        color: "white"
+    }, "Total Size: "), /*#__PURE__*/ React.createElement(Text, {
+        bold: true,
+        color: "yellow"
+    }, statistics.totalSizeFormatted)), /*#__PURE__*/ React.createElement(Text, null, /*#__PURE__*/ React.createElement(Text, {
+        color: "white"
+    }, "Selected: "), /*#__PURE__*/ React.createElement(Text, {
+        bold: true,
+        color: "cyan"
+    }, statistics.selectedCount), /*#__PURE__*/ React.createElement(Text, null, " (", statistics.selectedSizeFormatted, ")"))));
+};
+/**
+ * ListItem displays a single node_modules entry.
+ * Shows selection state, focus state, and visual indicators.
+ */ const ListItem = ({ item, isFocused })=>{
+    // Determine colors based on categories
+    const sizeColor = getSizeColor(item.sizeCategory);
+    const ageColor = item.ageCategory === 'stale' ? 'gray' : 'white';
+    const selectionIndicator = item.selected ? '[✓]' : '[ ]';
+    const focusIndicator = isFocused ? '>' : ' ';
+    // Warning indicator for large or old items
+    const warningIndicator = item.sizeCategory === 'huge' || item.ageCategory === 'stale' ? '⚠️ ' : '  ';
+    return /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, null, /*#__PURE__*/ React.createElement(Text, {
+        color: isFocused ? 'cyan' : 'white'
+    }, focusIndicator), /*#__PURE__*/ React.createElement(Text, {
+        color: item.selected ? 'green' : 'white'
+    }, selectionIndicator), /*#__PURE__*/ React.createElement(Text, null, " "), /*#__PURE__*/ React.createElement(Text, null, warningIndicator), /*#__PURE__*/ React.createElement(Text, null, "📁 "), /*#__PURE__*/ React.createElement(Text, {
+        bold: true
+    }, item.projectName), item.projectVersion && /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, " (v", item.projectVersion, ")"), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
+        color: sizeColor,
+        bold: true
+    }, item.sizeFormatted), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
+        color: ageColor
+    }, "[", item.lastModifiedFormatted, "]")));
+};
+/**
+ * List displays a scrollable list of node_modules.
+ * Handles virtual scrolling for performance with large lists.
+ */ const List = ({ items, selectedIndex, visibleCount })=>{
+    // Calculate visible range for virtual scrolling
+    const halfVisible = Math.floor(visibleCount / 2);
+    let startIndex = Math.max(0, selectedIndex - halfVisible);
+    let endIndex = Math.min(items.length, startIndex + visibleCount);
+    // Adjust start if we're near the end
+    if (endIndex - startIndex < visibleCount) {
+        startIndex = Math.max(0, endIndex - visibleCount);
+    }
+    const visibleItems = items.slice(startIndex, endIndex);
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        flexGrow: 1,
+        overflow: "hidden"
+    }, items.length === 0 ? /*#__PURE__*/ React.createElement(Box, {
+        padding: 2
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "No node_modules found. Press 'q' to quit.")) : /*#__PURE__*/ React.createElement(React.Fragment, null, startIndex > 0 && /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "↑ ", startIndex, " more..."), visibleItems.map((item, index)=>{
+        const actualIndex = startIndex + index;
+        return /*#__PURE__*/ React.createElement(ListItem, {
+            key: item.path,
+            item: item,
+            isFocused: actualIndex === selectedIndex
+        });
+    }), endIndex < items.length && /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "↓ ", items.length - endIndex, " more...")));
+};
+/**
+ * Footer displays keyboard shortcuts and current state.
+ */ const Footer = ({ sortBy, filterQuery })=>{
+    const sortLabel = getSortLabel(sortBy);
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        borderStyle: "single",
+        padding: 1
+    }, /*#__PURE__*/ React.createElement(Box, {
+        justifyContent: "space-between"
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "[↑/↓] Navigate  [Space] Toggle  [d] Delete  [a] Select all  [s] Sort (", sortLabel, ")  [f] Filter")), /*#__PURE__*/ React.createElement(Box, {
+        justifyContent: "space-between"
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "[i] Invert  [>] Select larger  [q] Quit  [?] Help"), filterQuery && /*#__PURE__*/ React.createElement(Text, {
+        color: "cyan"
+    }, "Filter: ", filterQuery)));
+};
+/**
+ * Help displays keyboard shortcuts and usage instructions.
+ */ const Help = ({ onClose })=>{
+    useInput((input, key)=>{
+        if (input === 'q' || key.escape) {
+            onClose();
+        }
+    });
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        borderStyle: "double",
+        padding: 2,
+        width: "80%"
+    }, /*#__PURE__*/ React.createElement(Text, {
+        bold: true,
+        color: "cyan"
+    }, "oh-my-node-modules - Keyboard Shortcuts"), /*#__PURE__*/ React.createElement(Box, {
+        marginY: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "Navigation")), /*#__PURE__*/ React.createElement(Text, null, "  ↑/↓ or j/k     Navigate up/down"), /*#__PURE__*/ React.createElement(Text, null, "  Space          Toggle selection"), /*#__PURE__*/ React.createElement(Text, null, "  Enter          Toggle selection"), /*#__PURE__*/ React.createElement(Box, {
+        marginY: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "Selection")), /*#__PURE__*/ React.createElement(Text, null, "  a              Select all visible"), /*#__PURE__*/ React.createElement(Text, null, "  n              Deselect all"), /*#__PURE__*/ React.createElement(Text, null, "  i              Invert selection"), /*#__PURE__*/ React.createElement(Text, null, "  ", '>', "              Select larger than previous"), /*#__PURE__*/ React.createElement(Box, {
+        marginY: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "Actions")), /*#__PURE__*/ React.createElement(Text, null, "  d              Delete selected"), /*#__PURE__*/ React.createElement(Text, null, "  s              Change sort order"), /*#__PURE__*/ React.createElement(Text, null, "  f              Filter/search"), /*#__PURE__*/ React.createElement(Box, {
+        marginY: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "Other")), /*#__PURE__*/ React.createElement(Text, null, "  q              Quit"), /*#__PURE__*/ React.createElement(Text, null, "  ?              Toggle this help"), /*#__PURE__*/ React.createElement(Text, null, "  Esc            Close help/exit filter"), /*#__PURE__*/ React.createElement(Box, {
+        marginTop: 2
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "Press any key to close...")));
+};
+/**
+ * ConfirmDialog asks for user confirmation before destructive actions.
+ */ const ConfirmDialog = ({ message, onConfirm, onCancel })=>{
+    useInput((input, key)=>{
+        if (input === 'y' || input === 'Y') {
+            onConfirm();
+        } else if (input === 'n' || input === 'N' || key.escape) {
+            onCancel();
+        }
+    });
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        borderStyle: "double",
+        borderColor: "yellow",
+        padding: 2,
+        width: "80%"
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "yellow",
+        bold: true
+    }, "⚠️  Confirmation Required"), /*#__PURE__*/ React.createElement(Box, {
+        marginY: 1
+    }, /*#__PURE__*/ React.createElement(Text, null, message)), /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, "Proceed? (y/N): "));
+};
+/**
+ * ProgressBar shows progress during long operations.
+ */ const ProgressBar = ({ current, total, label, operation })=>{
+    const percentage = total > 0 ? Math.round(current / total * 100) : 0;
+    const barWidth = 40;
+    const filledWidth = Math.round(percentage / 100 * barWidth);
+    const emptyWidth = barWidth - filledWidth;
+    const filledBar = '█'.repeat(filledWidth);
+    const emptyBar = '░'.repeat(emptyWidth);
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        borderStyle: "single",
+        padding: 1,
+        width: "80%"
+    }, /*#__PURE__*/ React.createElement(Text, {
+        bold: true
+    }, operation, "..."), /*#__PURE__*/ React.createElement(Box, {
+        marginY: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "cyan"
+    }, filledBar), /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, emptyBar), /*#__PURE__*/ React.createElement(Text, null, " ", percentage, "%")), /*#__PURE__*/ React.createElement(Text, {
+        color: "gray"
+    }, current, "/", total, ": ", label));
+};
+// ============================================
+// Helper Functions
+// ============================================
+function getSizeColor(category) {
+    switch(category){
+        case 'huge':
+            return 'red';
+        case 'large':
+            return 'yellow';
+        case 'medium':
+            return 'cyan';
+        case 'small':
+            return 'green';
+        default:
+            return 'white';
+    }
+}
+function getSortLabel(sortBy) {
+    const labels = {
+        'size-desc': 'size ↓',
+        'size-asc': 'size ↑',
+        'date-desc': 'date ↓',
+        'date-asc': 'date ↑',
+        'name-asc': 'name A-Z',
+        'name-desc': 'name Z-A',
+        'packages-desc': 'pkgs ↓',
+        'packages-asc': 'pkgs ↑'
+    };
+    return labels[sortBy] || sortBy;
+}
+
+/**
+ * Core type definitions for oh-my-node-modules
+ * 
+ * These types represent the domain model for node_modules analysis.
+ * Each interface answers a specific question about the data structure.
+ */ /** 
+ * Represents a discovered node_modules directory with all relevant metadata.
+ * This is the core data structure that flows through the entire application.
+ */ /**
+ * Initial state factory function.
+ * Creates a fresh application state with sensible defaults.
+ */ function createInitialState() {
+    return {
+        nodeModules: [],
+        selectedIndex: 0,
+        sortBy: 'size-desc',
+        filterQuery: '',
+        isScanning: false,
+        isDeleting: false,
+        scanProgress: 0,
+        sessionBytesReclaimed: 0,
+        showHelp: false
+    };
+}
+/**
+ * Thresholds for size categorization in bytes.
+ * Used to determine visual styling and smart selection rules.
+ */ const SIZE_THRESHOLDS = {
+    /** 100 MB - upper bound for "small" category */ SMALL: 100 * 1024 * 1024,
+    /** 500 MB - upper bound for "medium" category */ MEDIUM: 500 * 1024 * 1024,
+    /** 1 GB - upper bound for "large" category */ LARGE: 1024 * 1024 * 1024
+};
+/**
+ * Thresholds for age categorization in days.
+ * Used to identify stale node_modules that might be safe to delete.
+ */ const AGE_THRESHOLDS = {
+    /** 7 days - still considered fresh */ FRESH: 7,
+    /** 30 days - warning threshold */ RECENT: 30,
+    /** 90 days - stale threshold */ OLD: 90
+};
+
+/**
+ * Format bytes into human-readable string.
+ * Uses binary units (MiB, GiB) for accuracy.
+ * 
+ * @param bytes - Number of bytes to format
+ * @returns Formatted string like "1.2 GB" or "456 MB"
+ */ function formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const units = [
+        'B',
+        'KB',
+        'MB',
+        'GB',
+        'TB'
+    ];
+    const base = 1024;
+    const exponent = Math.floor(Math.log(bytes) / Math.log(base));
+    const unit = units[Math.min(exponent, units.length - 1)];
+    const value = bytes / Math.pow(base, exponent);
+    // Show 1 decimal place for MB and above, 0 for smaller
+    const decimals = exponent >= 2 ? 1 : 0;
+    return `${value.toFixed(decimals)} ${unit}`;
+}
+/**
+ * Parse human-readable size string into bytes.
+ * Supports formats like "1gb", "500MB", "10mb"
+ * 
+ * @param sizeStr - Size string to parse
+ * @returns Size in bytes, or undefined if invalid
+ */ function parseSize(sizeStr) {
+    const match = sizeStr.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb)?$/);
+    if (!match) return undefined;
+    const value = parseFloat(match[1]);
+    const unit = match[2] || 'b';
+    const multipliers = {
+        b: 1,
+        kb: 1024,
+        mb: 1024 * 1024,
+        gb: 1024 * 1024 * 1024,
+        tb: 1024 * 1024 * 1024 * 1024
+    };
+    return Math.floor(value * (multipliers[unit] || 1));
+}
+/**
+ * Format a date into "X days ago" string.
+ * Provides more readable relative time than raw dates.
+ * 
+ * @param date - Date to format
+ * @returns Formatted string like "30d ago" or "2d ago"
+ */ function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0) {
+        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+        if (diffHours === 0) {
+            const diffMinutes = Math.floor(diffMs / (1000 * 60));
+            return diffMinutes <= 1 ? 'just now' : `${diffMinutes}m ago`;
+        }
+        return `${diffHours}h ago`;
+    }
+    if (diffDays < 30) return `${diffDays}d ago`;
+    if (diffDays < 365) return `${Math.floor(diffDays / 30)}mo ago`;
+    return `${Math.floor(diffDays / 365)}y ago`;
+}
+/**
+ * Determine size category based on bytes.
+ * Used for color coding and smart selection.
+ * 
+ * @param bytes - Size in bytes
+ * @returns Size category
+ */ function getSizeCategory(bytes) {
+    if (bytes > SIZE_THRESHOLDS.LARGE) return 'huge';
+    if (bytes > SIZE_THRESHOLDS.MEDIUM) return 'large';
+    if (bytes > SIZE_THRESHOLDS.SMALL) return 'medium';
+    return 'small';
+}
+/**
+ * Determine age category based on days since modification.
+ * Used to identify potentially stale node_modules.
+ * 
+ * @param lastModified - Last modification date
+ * @returns Age category
+ */ function getAgeCategory(lastModified) {
+    const now = new Date();
+    const diffDays = Math.floor((now.getTime() - lastModified.getTime()) / (1000 * 60 * 60 * 24));
+    if (diffDays > AGE_THRESHOLDS.OLD) return 'stale';
+    if (diffDays > AGE_THRESHOLDS.RECENT) return 'old';
+    if (diffDays > AGE_THRESHOLDS.FRESH) return 'recent';
+    return 'fresh';
+}
+/**
+ * Calculate age in days from a date.
+ * 
+ * @param date - Date to calculate age from
+ * @returns Number of days
+ */ function getAgeInDays$1(date) {
+    const now = new Date();
+    return Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+}
+/**
+ * Sort node_modules by the specified option.
+ * Pure function that returns a new sorted array.
+ * 
+ * @param items - Array to sort
+ * @param sortBy - Sort option
+ * @returns New sorted array
+ */ function sortNodeModules(items, sortBy) {
+    const sorted = [
+        ...items
+    ]; // Create copy to avoid mutation
+    switch(sortBy){
+        case 'size-desc':
+            return sorted.sort((a, b)=>b.sizeBytes - a.sizeBytes);
+        case 'size-asc':
+            return sorted.sort((a, b)=>a.sizeBytes - b.sizeBytes);
+        case 'date-desc':
+            return sorted.sort((a, b)=>b.lastModified.getTime() - a.lastModified.getTime());
+        case 'date-asc':
+            return sorted.sort((a, b)=>a.lastModified.getTime() - b.lastModified.getTime());
+        case 'name-asc':
+            return sorted.sort((a, b)=>a.projectName.localeCompare(b.projectName));
+        case 'name-desc':
+            return sorted.sort((a, b)=>b.projectName.localeCompare(a.projectName));
+        case 'packages-desc':
+            return sorted.sort((a, b)=>b.totalPackageCount - a.totalPackageCount);
+        case 'packages-asc':
+            return sorted.sort((a, b)=>a.totalPackageCount - b.totalPackageCount);
+        default:
+            return sorted;
+    }
+}
+/**
+ * Filter node_modules by search query.
+ * Matches against project name and path.
+ * 
+ * @param items - Array to filter
+ * @param query - Search query (case-insensitive)
+ * @returns Filtered array
+ */ function filterNodeModules(items, query) {
+    if (!query.trim()) return items;
+    const lowerQuery = query.toLowerCase();
+    return items.filter((item)=>item.projectName.toLowerCase().includes(lowerQuery) || item.path.toLowerCase().includes(lowerQuery));
+}
+/**
+ * Calculate statistics from node_modules list.
+ * Used for overview displays and summaries.
+ * 
+ * @param items - Node modules to analyze
+ * @returns Calculated statistics
+ */ function calculateStatistics(items) {
+    const selectedItems = items.filter((item)=>item.selected);
+    const totalSize = items.reduce((sum, item)=>sum + item.sizeBytes, 0);
+    const selectedSize = selectedItems.reduce((sum, item)=>sum + item.sizeBytes, 0);
+    const totalAge = items.reduce((sum, item)=>{
+        return sum + getAgeInDays$1(item.lastModified);
+    }, 0);
+    const staleCount = items.filter((item)=>item.ageCategory === 'stale').length;
+    return {
+        totalProjects: new Set(items.map((item)=>item.projectPath)).size,
+        totalNodeModules: items.length,
+        totalSizeBytes: totalSize,
+        totalSizeFormatted: formatBytes(totalSize),
+        selectedCount: selectedItems.length,
+        selectedSizeBytes: selectedSize,
+        selectedSizeFormatted: formatBytes(selectedSize),
+        averageAgeDays: items.length > 0 ? Math.round(totalAge / items.length) : 0,
+        staleCount
+    };
+}
+/**
+ * Check if a path should be excluded based on patterns.
+ * Supports glob-like patterns with * and ? wildcards.
+ * 
+ * @param path - Path to check
+ * @param patterns - Exclusion patterns
+ * @returns True if path should be excluded
+ */ function shouldExcludePath(path, patterns) {
+    return patterns.some((pattern)=>{
+        // Convert glob pattern to regex
+        const regexPattern = pattern.replace(/\*\*/g, '{{GLOBSTAR}}').replace(/\*/g, '[^/]*').replace(/\?/g, '.').replace(/\{\{GLOBSTAR\}\}/g, '.*');
+        const regex = new RegExp(regexPattern, 'i');
+        return regex.test(path);
+    });
+}
+/**
+ * Toggle selection state for a node_modules item.
+ * Returns new array with toggled item (immutable update).
+ * 
+ * @param items - Current items array
+ * @param index - Index of item to toggle
+ * @returns New array with toggled selection
+ */ function toggleSelection(items, index) {
+    if (index < 0 || index >= items.length) return items;
+    return items.map((item, i)=>i === index ? {
+            ...item,
+            selected: !item.selected
+        } : item);
+}
+/**
+ * Safe file existence check that doesn't throw.
+ * Useful for checking if package.json exists before parsing.
+ * 
+ * @param path - Path to check
+ * @returns True if file exists
+ */ async function fileExists(path) {
+    try {
+        await promises.access(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Read and parse package.json safely.
+ * Returns undefined if file doesn't exist or is invalid.
+ * 
+ * @param projectPath - Path to project directory
+ * @returns Parsed package.json or undefined
+ */ async function readPackageJson(projectPath) {
+    const packagePath = join(projectPath, 'package.json');
+    try {
+        const content = await promises.readFile(packagePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return parsed;
+    } catch  {
+        return undefined;
+    }
+}
+
+/**
+ * Recursively scan for node_modules directories starting from root path.
+ * 
+ * This is the main entry point for discovery. It walks the directory tree,
+ * identifies node_modules folders, and collects metadata about each one.
+ * 
+ * @param options - Scan configuration options
+ * @param onProgress - Optional callback for progress updates (0-100)
+ * @returns Scan results with all discovered node_modules
+ */ async function scanForNodeModules(options, onProgress) {
+    const result = {
+        nodeModules: [],
+        directoriesScanned: 0,
+        errors: []
+    };
+    const visitedPaths = new Set();
+    const pathsToScan = [
+        {
+            path: options.rootPath,
+            depth: 0
+        }
+    ];
+    let processedCount = 0;
+    let totalEstimate = 1; // Start with 1, will adjust as we discover
+    while(pathsToScan.length > 0){
+        const { path: currentPath, depth } = pathsToScan.shift();
+        // Skip if already visited or exceeds max depth
+        if (visitedPaths.has(currentPath)) continue;
+        if (options.maxDepth !== undefined && depth > options.maxDepth) continue;
+        if (shouldExcludePath(currentPath, options.excludePatterns)) continue;
+        visitedPaths.add(currentPath);
+        result.directoriesScanned++;
+        try {
+            const entries = await promises.readdir(currentPath, {
+                withFileTypes: true
+            });
+            // Check if current directory has node_modules
+            const hasNodeModules = entries.some((entry)=>entry.isDirectory() && entry.name === 'node_modules');
+            if (hasNodeModules) {
+                const nodeModulesPath = join(currentPath, 'node_modules');
+                const info = await analyzeNodeModules(nodeModulesPath, currentPath);
+                // Apply filters
+                if (options.minSizeBytes && info.sizeBytes < options.minSizeBytes) {
+                // Skip - too small
+                } else if (options.olderThanDays && getAgeInDays(info.lastModified) < options.olderThanDays) {
+                // Skip - too recent
+                } else {
+                    result.nodeModules.push(info);
+                }
+            }
+            // Add subdirectories to scan queue (excluding node_modules itself)
+            for (const entry of entries){
+                if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+                    const subPath = join(currentPath, entry.name);
+                    if (!shouldExcludePath(subPath, options.excludePatterns)) {
+                        pathsToScan.push({
+                            path: subPath,
+                            depth: depth + 1
+                        });
+                        totalEstimate++;
+                    }
+                }
+            }
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push(`Error scanning ${currentPath}: ${errorMessage}`);
+        }
+        // Report progress
+        processedCount++;
+        if (onProgress) {
+            const progress = Math.min(100, Math.round(processedCount / totalEstimate * 100));
+            onProgress(progress);
+        }
+    }
+    // Ensure we report 100% at the end
+    if (onProgress) {
+        onProgress(100);
+    }
+    return result;
+}
+/**
+ * Analyze a specific node_modules directory and extract all metadata.
+ * 
+ * This function performs the heavy lifting of:
+ * - Calculating total size (recursive)
+ * - Counting packages
+ * - Reading parent project info
+ * - Determining age and size categories
+ * 
+ * @param nodeModulesPath - Path to node_modules directory
+ * @param projectPath - Path to parent project (containing package.json)
+ * @returns Complete metadata for the node_modules
+ */ async function analyzeNodeModules(nodeModulesPath, projectPath) {
+    // Get basic stats
+    const stats = await promises.stat(nodeModulesPath);
+    // Calculate size and count packages
+    const { totalSize, packageCount, totalPackageCount } = await calculateDirectorySize(nodeModulesPath);
+    // Read project info from package.json
+    const packageJson = await readPackageJson(projectPath);
+    const projectName = packageJson?.name || basename(projectPath);
+    const projectVersion = packageJson?.version;
+    // Determine categories
+    const sizeCategory = getSizeCategory(totalSize);
+    const ageCategory = getAgeCategory(stats.mtime);
+    return {
+        path: nodeModulesPath,
+        projectPath,
+        projectName,
+        projectVersion,
+        sizeBytes: totalSize,
+        sizeFormatted: formatBytes(totalSize),
+        packageCount,
+        totalPackageCount,
+        lastModified: stats.mtime,
+        lastModifiedFormatted: formatRelativeTime(stats.mtime),
+        selected: false,
+        isFavorite: false,
+        ageCategory,
+        sizeCategory
+    };
+}
+/**
+ * Recursively calculate directory size and package counts.
+ * 
+ * This is an expensive operation for large node_modules directories.
+ * We optimize by:
+ * - Using iterative approach (avoid stack overflow)
+ * - Counting only top-level packages for packageCount
+ * - Counting all packages for totalPackageCount
+ * 
+ * @param dirPath - Directory to analyze
+ * @returns Size in bytes and package counts
+ */ async function calculateDirectorySize(dirPath) {
+    let totalSize = 0;
+    let packageCount = 0;
+    let totalPackageCount = 0;
+    let isTopLevel = true;
+    const pathsToProcess = [
+        dirPath
+    ];
+    const processedPaths = new Set();
+    while(pathsToProcess.length > 0){
+        const currentPath = pathsToProcess.pop();
+        if (processedPaths.has(currentPath)) continue;
+        processedPaths.add(currentPath);
+        try {
+            const stats = await promises.stat(currentPath);
+            if (stats.isFile()) {
+                totalSize += stats.size;
+            } else if (stats.isDirectory()) {
+                // Add directory entry size (approximate)
+                totalSize += 4096; // Typical directory entry size
+                // Count packages at top level only
+                if (isTopLevel && currentPath !== dirPath) {
+                    const entryName = basename(currentPath);
+                    // Skip hidden directories and special directories
+                    if (!entryName.startsWith('.') && entryName !== '.bin') {
+                        packageCount++;
+                    }
+                }
+                // Count all packages for total
+                if (currentPath !== dirPath) {
+                    const entryName = basename(currentPath);
+                    if (!entryName.startsWith('.') && entryName !== '.bin') {
+                        totalPackageCount++;
+                    }
+                }
+                // Read directory contents
+                try {
+                    const entries = await promises.readdir(currentPath, {
+                        withFileTypes: true
+                    });
+                    for (const entry of entries){
+                        const entryPath = join(currentPath, entry.name);
+                        pathsToProcess.push(entryPath);
+                    }
+                } catch  {
+                // Permission denied or other error - skip this directory
+                }
+            } else if (stats.isSymbolicLink()) {
+            // Skip symbolic links to avoid cycles
+            }
+        } catch  {
+        // File not accessible - skip
+        }
+        if (currentPath === dirPath) {
+            isTopLevel = false;
+        }
+    }
+    return {
+        totalSize,
+        packageCount,
+        totalPackageCount
+    };
+}
+/**
+ * Helper to get age in days from a date.
+ */ function getAgeInDays(date) {
+    const now = new Date();
+    return Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+}
+/**
+ * Load ignore patterns from .onmignore file.
+ * 
+ * Looks for .onmignore in:
+ * 1. Current working directory
+ * 2. Home directory
+ * 
+ * @returns Array of ignore patterns
+ */ async function loadIgnorePatterns() {
+    const patterns = [
+        '**/node_modules/**',
+        '**/.git/**',
+        '**/.*'
+    ];
+    const ignoreFiles = [
+        join(process.cwd(), '.onmignore'),
+        join(process.env.HOME || process.cwd(), '.onmignore')
+    ];
+    for (const ignoreFile of ignoreFiles){
+        try {
+            if (await fileExists(ignoreFile)) {
+                const content = await promises.readFile(ignoreFile, 'utf-8');
+                const lines = content.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.startsWith('#'));
+                patterns.push(...lines);
+            }
+        } catch  {
+        // Ignore errors reading ignore files
+        }
+    }
+    return patterns;
+}
+/**
+ * Load favorites list from .onmfavorites file.
+ * 
+ * Favorites are projects that should never be suggested for deletion.
+ * 
+ * @returns Set of favorite project paths
+ */ async function loadFavorites() {
+    const favorites = new Set();
+    const favoritesFile = join(process.env.HOME || process.cwd(), '.onmfavorites');
+    try {
+        if (await fileExists(favoritesFile)) {
+            const content = await promises.readFile(favoritesFile, 'utf-8');
+            const lines = content.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.startsWith('#'));
+            for (const line of lines){
+                favorites.add(line);
+            }
+        }
+    } catch  {
+    // Ignore errors reading favorites
+    }
+    return favorites;
+}
+/**
+ * Check if a node_modules directory is currently in use.
+ * 
+ * This is a safety check to prevent deleting node_modules that
+ * might be actively being used by a running process.
+ * 
+ * Note: This is a best-effort check and may not catch all cases.
+ * 
+ * @param path - Path to node_modules
+ * @returns True if potentially in use
+ */ async function isNodeModulesInUse(path) {
+    // This is a simplified check - in production, you might want to:
+    // 1. Check for lock files
+    // 2. Check for running node processes using this path
+    // 3. Check for open file handles
+    try {
+        const lockFiles = [
+            '.package-lock.json',
+            'yarn.lock',
+            'pnpm-lock.yaml'
+        ];
+        const projectPath = dirname(path);
+        for (const lockFile of lockFiles){
+            const lockPath = join(projectPath, lockFile);
+            try {
+                const stats = await promises.stat(lockPath);
+                // If lock file was modified in the last minute, might be in use
+                const oneMinuteAgo = Date.now() - 60 * 1000;
+                if (stats.mtime.getTime() > oneMinuteAgo) {
+                    return true;
+                }
+            } catch  {
+            // Lock file doesn't exist - that's fine
+            }
+        }
+    } catch  {
+    // Error checking - assume not in use
+    }
+    return false;
+}
+
+/**
+ * Delete selected node_modules directories.
+ * 
+ * This is the main entry point for deletion operations. It:
+ * 1. Filters to only selected items
+ * 2. Performs safety checks
+ * 3. Deletes each node_modules (or simulates in dry run)
+ * 4. Collects results and statistics
+ * 
+ * @param nodeModules - List of all node_modules (selected ones will be deleted)
+ * @param options - Deletion options
+ * @param onProgress - Optional callback for progress updates
+ * @returns Deletion results with statistics
+ */ async function deleteSelectedNodeModules(nodeModules, options, onProgress) {
+    const selected = nodeModules.filter((nm)=>nm.selected);
+    const result = {
+        totalAttempted: selected.length,
+        successful: 0,
+        failed: 0,
+        bytesFreed: 0,
+        formattedBytesFreed: '0 B',
+        details: []
+    };
+    for(let i = 0; i < selected.length; i++){
+        const item = selected[i];
+        if (onProgress) {
+            onProgress(i + 1, selected.length, item.projectName);
+        }
+        const detail = await deleteNodeModules(item, options);
+        result.details.push(detail);
+        if (detail.success) {
+            result.successful++;
+            result.bytesFreed += item.sizeBytes;
+        } else {
+            result.failed++;
+        }
+    }
+    result.formattedBytesFreed = formatBytes(result.bytesFreed);
+    return result;
+}
+/**
+ * Delete a single node_modules directory.
+ * 
+ * Performs safety checks before deletion:
+ * - Verifies it's actually a node_modules directory
+ * - Checks if it's in use (if enabled)
+ * - Verifies the path is valid
+ * 
+ * @param nodeModules - NodeModulesInfo to delete
+ * @param options - Deletion options
+ * @returns Detailed result of the deletion
+ */ async function deleteNodeModules(nodeModules, options) {
+    const startTime = Date.now();
+    const detail = {
+        nodeModules,
+        success: false,
+        durationMs: 0
+    };
+    try {
+        // Safety check 1: Verify path ends with node_modules
+        if (!nodeModules.path.endsWith('node_modules')) {
+            detail.error = 'Path does not appear to be a node_modules directory';
+            detail.durationMs = Date.now() - startTime;
+            return detail;
+        }
+        // Safety check 2: Verify directory exists
+        if (!await fileExists(nodeModules.path)) {
+            detail.error = 'Directory does not exist';
+            detail.durationMs = Date.now() - startTime;
+            return detail;
+        }
+        // Safety check 3: Check if in use
+        if (options.checkRunningProcesses) {
+            const inUse = await isNodeModulesInUse(nodeModules.path);
+            if (inUse) {
+                detail.error = 'Directory appears to be in use by a running process';
+                detail.durationMs = Date.now() - startTime;
+                return detail;
+            }
+        }
+        // Safety check 4: Verify it looks like a real node_modules
+        const isValidNodeModules = await verifyNodeModules(nodeModules.path);
+        if (!isValidNodeModules) {
+            detail.error = 'Directory does not appear to be a valid node_modules';
+            detail.durationMs = Date.now() - startTime;
+            return detail;
+        }
+        // Perform deletion (or simulate)
+        if (options.dryRun) {
+            // In dry run, just simulate success
+            detail.success = true;
+        } else {
+            // Actually delete the directory
+            await promises.rm(nodeModules.path, {
+                recursive: true,
+                force: true
+            });
+            detail.success = true;
+        }
+        detail.durationMs = Date.now() - startTime;
+    } catch (error) {
+        detail.error = error instanceof Error ? error.message : String(error);
+        detail.durationMs = Date.now() - startTime;
+    }
+    return detail;
+}
+/**
+ * Verify that a directory looks like a real node_modules.
+ * 
+ * We check for:
+ * - Directory name is exactly "node_modules"
+ * - Contains at least one subdirectory (package)
+ * - Parent directory contains package.json
+ * 
+ * These checks prevent accidental deletion of similarly named directories.
+ * 
+ * @param path - Path to verify
+ * @returns True if it looks like a valid node_modules
+ */ async function verifyNodeModules(path) {
+    try {
+        // Check name
+        const parts = path.split('/');
+        if (parts[parts.length - 1] !== 'node_modules') {
+            return false;
+        }
+        // Check it has contents (not empty)
+        const entries = await promises.readdir(path);
+        const hasSubdirs = entries.some(async (entry)=>{
+            const entryPath = join(path, entry);
+            const stats = await promises.stat(entryPath);
+            return stats.isDirectory();
+        });
+        // Parent should have package.json
+        const parentPath = path.replace(/\/node_modules$/, '').replace(/\\node_modules$/, '');
+        const hasPackageJson = await fileExists(join(parentPath, 'package.json'));
+        return hasSubdirs || hasPackageJson;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Generate a preview report of what would be deleted.
+ * 
+ * Used for dry run mode and confirmation prompts.
+ * 
+ * @param nodeModules - All node_modules items
+ * @returns Formatted report string
+ */ function generateDeletionPreview(nodeModules) {
+    const selected = nodeModules.filter((nm)=>nm.selected);
+    if (selected.length === 0) {
+        return 'No node_modules selected for deletion.';
+    }
+    const totalBytes = selected.reduce((sum, nm)=>sum + nm.sizeBytes, 0);
+    let report = `\n⚠️  You are about to delete ${selected.length} node_modules director${selected.length === 1 ? 'y' : 'ies'}:\n\n`;
+    for (const nm of selected){
+        const shortPath = nm.path.replace(process.cwd(), '.');
+        report += `   • ${shortPath} (${nm.sizeFormatted})\n`;
+    }
+    report += `\n   Total space to reclaim: ${formatBytes(totalBytes)}\n`;
+    return report;
+}
+/**
+ * Select node_modules by size criteria.
+ * 
+ * Helper for "select all >500MB" functionality.
+ * 
+ * @param nodeModules - All node_modules
+ * @param minSizeBytes - Minimum size in bytes
+ * @returns Updated array with selections
+ */ function selectBySize(nodeModules, minSizeBytes) {
+    return nodeModules.map((nm)=>nm.sizeBytes >= minSizeBytes ? {
+            ...nm,
+            selected: true
+        } : nm);
+}
+/**
+ * Select all node_modules.
+ * 
+ * @param nodeModules - All node_modules
+ * @param selected - Whether to select (true) or deselect (false)
+ * @returns Updated array
+ */ function selectAll(nodeModules, selected) {
+    return nodeModules.map((nm)=>({
+            ...nm,
+            selected
+        }));
+}
+/**
+ * Invert selection.
+ * 
+ * @param nodeModules - All node_modules
+ * @returns Updated array with inverted selections
+ */ function invertSelection(nodeModules) {
+    return nodeModules.map((nm)=>({
+            ...nm,
+            selected: !nm.selected
+        }));
+}
+
+/**
+ * Main application component.
+ *
+ * Manages all application state and coordinates between:
+ * - Scanner (discovery)
+ * - UI components (rendering)
+ * - Deletion operations
+ * - User input
+ */ const App = ({ rootPath, initialSort = 'size-desc' })=>{
+    // Get terminal dimensions for responsive layout
+    const { stdout } = useStdout();
+    const { exit } = useApp();
+    // Application state
+    const [state, setState] = useState(()=>({
+            ...createInitialState(),
+            sortBy: initialSort
+        }));
+    // UI state (not part of core app state)
+    const [showHelp, setShowHelp] = useState(false);
+    const [showConfirm, setShowConfirm] = useState(false);
+    const [showFilter, setShowFilter] = useState(false);
+    const [showProgress, setShowProgress] = useState(false);
+    const [progressState, setProgressState] = useState({
+        current: 0,
+        total: 0,
+        label: ''
+    });
+    const [filterInput, setFilterInput] = useState('');
+    const [errorMessage, setErrorMessage] = useState();
+    // Derived state: sorted and filtered items
+    const sortedItems = useMemo(()=>{
+        const sorted = sortNodeModules(state.nodeModules, state.sortBy);
+        return sorted;
+    }, [
+        state.nodeModules,
+        state.sortBy
+    ]);
+    const filteredItems = useMemo(()=>{
+        return filterNodeModules(sortedItems, state.filterQuery);
+    }, [
+        sortedItems,
+        state.filterQuery
+    ]);
+    // Calculate statistics from current items
+    const statistics = useMemo(()=>{
+        return calculateStatistics(filteredItems);
+    }, [
+        filteredItems
+    ]);
+    // Calculate visible list size based on terminal height
+    const visibleListCount = useMemo(()=>{
+        // Reserve space for header, footer, and padding
+        const reservedLines = 12;
+        return Math.max(5, stdout.rows - reservedLines);
+    }, [
+        stdout.rows
+    ]);
+    // ============================================
+    // Effects
+    // ============================================
+    // Scan on mount
+    useEffect(()=>{
+        const performScan = async ()=>{
+            setState((prev)=>({
+                    ...prev,
+                    isScanning: true
+                }));
+            try {
+                const excludePatterns = await loadIgnorePatterns();
+                const favorites = await loadFavorites();
+                const result = await scanForNodeModules({
+                    rootPath,
+                    excludePatterns,
+                    followSymlinks: false
+                }, (progress)=>{
+                    setState((prev)=>({
+                            ...prev,
+                            scanProgress: progress
+                        }));
+                });
+                // Mark favorites
+                const itemsWithFavorites = result.nodeModules.map((item)=>({
+                        ...item,
+                        isFavorite: favorites.has(item.projectPath)
+                    }));
+                setState((prev)=>({
+                        ...prev,
+                        nodeModules: itemsWithFavorites,
+                        isScanning: false,
+                        scanProgress: 100
+                    }));
+                if (result.errors.length > 0) {
+                    setErrorMessage(`Scan completed with ${result.errors.length} errors`);
+                }
+            } catch (error) {
+                setState((prev)=>({
+                        ...prev,
+                        isScanning: false
+                    }));
+                setErrorMessage(error instanceof Error ? error.message : 'Scan failed');
+            }
+        };
+        performScan();
+    }, [
+        rootPath
+    ]);
+    // ============================================
+    // Keyboard Handlers
+    // ============================================
+    useInput((input, key)=>{
+        // Don't handle input during certain states
+        if (state.isDeleting || showConfirm || showProgress) return;
+        // Help overlay takes precedence
+        if (showHelp) {
+            if (input === 'q' || key.escape) {
+                setShowHelp(false);
+            }
+            return;
+        }
+        // Filter mode
+        if (showFilter) {
+            if (key.escape) {
+                setShowFilter(false);
+                setFilterInput('');
+                setState((prev)=>({
+                        ...prev,
+                        filterQuery: ''
+                    }));
+            } else if (key.return) {
+                setShowFilter(false);
+                setState((prev)=>({
+                        ...prev,
+                        filterQuery: filterInput
+                    }));
+            } else if (key.backspace || key.delete) {
+                setFilterInput((prev)=>prev.slice(0, -1));
+            } else if (input && !key.ctrl && !key.meta) {
+                setFilterInput((prev)=>prev + input);
+            }
+            return;
+        }
+        // Navigation
+        if (key.upArrow || input === 'k') {
+            setState((prev)=>({
+                    ...prev,
+                    selectedIndex: Math.max(0, prev.selectedIndex - 1)
+                }));
+        } else if (key.downArrow || input === 'j') {
+            setState((prev)=>({
+                    ...prev,
+                    selectedIndex: Math.min(filteredItems.length - 1, prev.selectedIndex + 1)
+                }));
+        } else if (input === ' ' || key.return) {
+            setState((prev)=>{
+                const newItems = toggleSelection(filteredItems, prev.selectedIndex);
+                return {
+                    ...prev,
+                    nodeModules: prev.nodeModules.map((item)=>{
+                        const updated = newItems.find((n)=>n.path === item.path);
+                        return updated || item;
+                    })
+                };
+            });
+        } else if (input === 'a') {
+            setState((prev)=>{
+                const allSelected = filteredItems.every((item)=>item.selected);
+                const newItems = selectAll(filteredItems, !allSelected);
+                return {
+                    ...prev,
+                    nodeModules: prev.nodeModules.map((item)=>{
+                        const updated = newItems.find((n)=>n.path === item.path);
+                        return updated || item;
+                    })
+                };
+            });
+        } else if (input === 'n') {
+            setState((prev)=>{
+                const newItems = selectAll(filteredItems, false);
+                return {
+                    ...prev,
+                    nodeModules: prev.nodeModules.map((item)=>{
+                        const updated = newItems.find((n)=>n.path === item.path);
+                        return updated || item;
+                    })
+                };
+            });
+        } else if (input === 'i') {
+            setState((prev)=>{
+                const newItems = invertSelection(filteredItems);
+                return {
+                    ...prev,
+                    nodeModules: prev.nodeModules.map((item)=>{
+                        const updated = newItems.find((n)=>n.path === item.path);
+                        return updated || item;
+                    })
+                };
+            });
+        } else if (input === '>') {
+            const currentItem = filteredItems[state.selectedIndex];
+            if (currentItem) {
+                setState((prev)=>{
+                    const newItems = selectBySize(filteredItems, currentItem.sizeBytes);
+                    return {
+                        ...prev,
+                        nodeModules: prev.nodeModules.map((item)=>{
+                            const updated = newItems.find((n)=>n.path === item.path);
+                            return updated || item;
+                        })
+                    };
+                });
+            }
+        } else if (input === 'd') {
+            const selected = filteredItems.filter((item)=>item.selected);
+            if (selected.length > 0) {
+                setShowConfirm(true);
+            }
+        } else if (input === 's') {
+            setState((prev)=>{
+                const sorts = [
+                    'size-desc',
+                    'size-asc',
+                    'date-desc',
+                    'date-asc',
+                    'name-asc',
+                    'name-desc',
+                    'packages-desc',
+                    'packages-asc'
+                ];
+                const currentIndex = sorts.indexOf(prev.sortBy);
+                const nextIndex = (currentIndex + 1) % sorts.length;
+                return {
+                    ...prev,
+                    sortBy: sorts[nextIndex]
+                };
+            });
+        } else if (input === 'f') {
+            setShowFilter(true);
+            setFilterInput(state.filterQuery);
+        } else if (input === '?') {
+            setShowHelp(true);
+        } else if (input === 'q') {
+            exit();
+        }
+    });
+    // ============================================
+    // Action Handlers
+    // ============================================
+    const handleConfirmDelete = useCallback(async ()=>{
+        setShowConfirm(false);
+        setShowProgress(true);
+        setState((prev)=>({
+                ...prev,
+                isDeleting: true
+            }));
+        const options = {
+            dryRun: false,
+            yes: true,
+            checkRunningProcesses: true,
+            showProgress: true
+        };
+        try {
+            const result = await deleteSelectedNodeModules(state.nodeModules, options, (current, total, label)=>{
+                setProgressState({
+                    current,
+                    total,
+                    label
+                });
+            });
+            // Update state to reflect deletions
+            setState((prev)=>({
+                    ...prev,
+                    nodeModules: prev.nodeModules.filter((nm)=>!result.details.find((d)=>d.nodeModules.path === nm.path && d.success)),
+                    isDeleting: false,
+                    sessionBytesReclaimed: prev.sessionBytesReclaimed + result.bytesFreed
+                }));
+            setShowProgress(false);
+        } catch (error) {
+            setState((prev)=>({
+                    ...prev,
+                    isDeleting: false
+                }));
+            setShowProgress(false);
+            setErrorMessage(error instanceof Error ? error.message : 'Deletion failed');
+        }
+    }, [
+        state.nodeModules,
+        exit
+    ]);
+    const handleCancelDelete = useCallback(()=>{
+        setShowConfirm(false);
+    }, []);
+    // ============================================
+    // Render
+    // ============================================
+    // If showing help overlay
+    if (showHelp) {
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column",
+            height: stdout.rows
+        }, /*#__PURE__*/ React.createElement(Header, {
+            statistics: statistics,
+            isScanning: state.isScanning,
+            scanProgress: state.scanProgress
+        }), /*#__PURE__*/ React.createElement(Box, {
+            flexGrow: 1,
+            alignItems: "center",
+            justifyContent: "center"
+        }, /*#__PURE__*/ React.createElement(Help, {
+            onClose: ()=>setShowHelp(false)
+        })));
+    }
+    // If showing confirmation dialog
+    if (showConfirm) {
+        const preview = generateDeletionPreview(filteredItems);
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column",
+            height: stdout.rows
+        }, /*#__PURE__*/ React.createElement(Header, {
+            statistics: statistics,
+            isScanning: state.isScanning,
+            scanProgress: state.scanProgress
+        }), /*#__PURE__*/ React.createElement(Box, {
+            flexGrow: 1,
+            alignItems: "center",
+            justifyContent: "center"
+        }, /*#__PURE__*/ React.createElement(ConfirmDialog, {
+            message: preview,
+            onConfirm: handleConfirmDelete,
+            onCancel: handleCancelDelete
+        })));
+    }
+    // If showing progress
+    if (showProgress) {
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column",
+            height: stdout.rows
+        }, /*#__PURE__*/ React.createElement(Header, {
+            statistics: statistics,
+            isScanning: state.isScanning,
+            scanProgress: state.scanProgress
+        }), /*#__PURE__*/ React.createElement(Box, {
+            flexGrow: 1,
+            alignItems: "center",
+            justifyContent: "center"
+        }, /*#__PURE__*/ React.createElement(ProgressBar, {
+            current: progressState.current,
+            total: progressState.total,
+            label: progressState.label,
+            operation: "Deleting"
+        })));
+    }
+    // If showing filter input
+    if (showFilter) {
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column",
+            height: stdout.rows
+        }, /*#__PURE__*/ React.createElement(Header, {
+            statistics: statistics,
+            isScanning: state.isScanning,
+            scanProgress: state.scanProgress
+        }), /*#__PURE__*/ React.createElement(Box, {
+            flexGrow: 1,
+            alignItems: "center",
+            justifyContent: "center",
+            borderStyle: "single",
+            padding: 2
+        }, /*#__PURE__*/ React.createElement(Text, null, "Filter: "), /*#__PURE__*/ React.createElement(Text, {
+            color: "cyan"
+        }, filterInput), /*#__PURE__*/ React.createElement(Text, {
+            color: "gray"
+        }, "_")), /*#__PURE__*/ React.createElement(Footer, {
+            sortBy: state.sortBy,
+            filterQuery: state.filterQuery
+        }));
+    }
+    // Main TUI view
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column",
+        height: stdout.rows
+    }, /*#__PURE__*/ React.createElement(Header, {
+        statistics: statistics,
+        isScanning: state.isScanning,
+        scanProgress: state.scanProgress
+    }), errorMessage && /*#__PURE__*/ React.createElement(Box, {
+        padding: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        color: "red"
+    }, "⚠️ ", errorMessage)), /*#__PURE__*/ React.createElement(Box, {
+        flexGrow: 1,
+        overflow: "hidden"
+    }, /*#__PURE__*/ React.createElement(List, {
+        items: filteredItems,
+        selectedIndex: state.selectedIndex,
+        visibleCount: visibleListCount
+    })), /*#__PURE__*/ React.createElement(Footer, {
+        sortBy: state.sortBy,
+        filterQuery: state.filterQuery
+    }));
+};
+
+/**
+ * Parse command-line arguments into structured config.
+ * 
+ * Supports:
+ * - Positional path argument
+ * - --scan (quick scan mode)
+ * - --auto (auto-delete mode)
+ * - --dry-run (simulate deletions)
+ * - --min-size (size threshold)
+ * - --yes (skip confirmations)
+ * - --json (JSON output)
+ * - --help (show help)
+ * - --version (show version)
+ * 
+ * @param args - Raw command-line arguments
+ * @returns Parsed configuration
+ */ function parseArgs(args) {
+    const result = {
+        path: process.cwd(),
+        scan: false,
+        auto: false,
+        dryRun: false,
+        yes: false,
+        json: false,
+        help: false,
+        version: false
+    };
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        switch(arg){
+            case '--scan':
+                result.scan = true;
+                break;
+            case '--auto':
+                result.auto = true;
+                break;
+            case '--dry-run':
+                result.dryRun = true;
+                break;
+            case '--yes':
+            case '-y':
+                result.yes = true;
+                break;
+            case '--json':
+                result.json = true;
+                break;
+            case '--help':
+            case '-h':
+                result.help = true;
+                break;
+            case '--version':
+            case '-v':
+                result.version = true;
+                break;
+            case '--min-size':
+                result.minSize = args[++i];
+                break;
+            default:
+                // If it doesn't start with -, treat as path
+                if (!arg.startsWith('-')) {
+                    result.path = arg;
+                }
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Show help message and exit.
+ */ function showHelp() {
+    console.log(`
+oh-my-node-modules - Visualize and clean up node_modules directories
+
+Usage:
+  onm [path] [options]
+
+Arguments:
+  path                    Directory to scan (default: current directory)
+
+Options:
+  --scan                  Quick scan mode (no TUI, just report)
+  --auto                  Auto-delete mode (no TUI, delete matching criteria)
+  --dry-run               Simulate deletions without actually deleting
+  --min-size <size>       Minimum size threshold (e.g., 1gb, 500mb)
+  --yes, -y               Skip confirmations
+  --json                  Output as JSON
+  --help, -h              Show this help message
+  --version, -v           Show version
+
+Interactive Mode (default):
+  onm                     Start interactive TUI
+  onm /path/to/projects   Scan specific directory
+
+Quick Scan Mode:
+  onm --scan              Quick scan and summary
+  onm --scan --json       Output JSON report
+
+Auto-Delete Mode:
+  onm --auto --min-size 1gb --yes    Delete all >1GB without prompting
+  onm --auto --dry-run               Preview what would be deleted
+
+Keyboard Shortcuts (Interactive Mode):
+  ↑/↓ or j/k         Navigate
+  Space or Enter     Toggle selection
+  a                  Select all
+  n                  Deselect all
+  i                  Invert selection
+  >                  Select larger than current
+  d                  Delete selected
+  s                  Change sort order
+  f                  Filter/search
+  q                  Quit
+  ?                  Show help
+
+Examples:
+  # Start interactive TUI in current directory
+  onm
+
+  # Scan specific directory
+  onm ~/projects
+
+  # Quick scan and report
+  onm --scan
+
+  # Preview deletion of large node_modules
+  onm --auto --min-size 500mb --dry-run
+
+  # Delete all node_modules >1GB without confirmation
+  onm --auto --min-size 1gb --yes
+`);
+}
+/**
+ * Show version and exit.
+ */ function showVersion() {
+    console.log('oh-my-node-modules v1.0.0');
+}
+/**
+ * Quick scan mode - scan and report without TUI.
+ */ async function runQuickScan(args) {
+    console.log('Scanning for node_modules...\n');
+    try {
+        const excludePatterns = await loadIgnorePatterns();
+        const result = await scanForNodeModules({
+            rootPath: args.path,
+            excludePatterns,
+            followSymlinks: false
+        });
+        const sorted = sortNodeModules(result.nodeModules, 'size-desc');
+        const stats = calculateStatistics(sorted);
+        if (args.json) {
+            console.log(JSON.stringify({
+                summary: stats,
+                nodeModules: sorted.map((nm)=>({
+                        path: nm.path,
+                        projectName: nm.projectName,
+                        projectVersion: nm.projectVersion,
+                        sizeBytes: nm.sizeBytes,
+                        sizeFormatted: nm.sizeFormatted,
+                        packageCount: nm.packageCount,
+                        lastModified: nm.lastModified,
+                        lastModifiedFormatted: nm.lastModifiedFormatted
+                    }))
+            }, null, 2));
+        } else {
+            console.log(`Found ${stats.totalProjects} projects with node_modules`);
+            console.log(`Total size: ${stats.totalSizeFormatted}\n`);
+            if (sorted.length > 0) {
+                console.log('Projects (sorted by size):');
+                console.log('─'.repeat(80));
+                for (const nm of sorted){
+                    const warning = nm.sizeCategory === 'huge' ? ' ⚠️' : '';
+                    console.log(`${nm.sizeFormatted.padStart(10)}  ${nm.projectName}${warning}  [${nm.lastModifiedFormatted}]`);
+                }
+            }
+            if (result.errors.length > 0) {
+                console.log(`\n⚠️  ${result.errors.length} errors during scan`);
+            }
+        }
+    } catch (error) {
+        console.error('Scan failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+/**
+ * Auto-delete mode - delete without TUI.
+ */ async function runAutoDelete(args) {
+    console.log('Scanning for node_modules...\n');
+    try {
+        const excludePatterns = await loadIgnorePatterns();
+        const result = await scanForNodeModules({
+            rootPath: args.path,
+            excludePatterns,
+            followSymlinks: false
+        });
+        let items = result.nodeModules;
+        // Apply size filter if specified
+        if (args.minSize) {
+            const minBytes = parseSize(args.minSize);
+            if (minBytes) {
+                items = selectBySize(items, minBytes);
+            }
+        }
+        const selected = items.filter((nm)=>nm.selected);
+        if (selected.length === 0) {
+            console.log('No node_modules match the criteria.');
+            return;
+        }
+        // Show preview
+        const preview = generateDeletionPreview(items);
+        console.log(preview);
+        // Confirm unless --yes
+        if (!args.yes) {
+            // In real implementation, would use clack prompts here
+            console.log('Use --yes to proceed without confirmation.');
+            return;
+        }
+        // Delete
+        const options = {
+            dryRun: args.dryRun,
+            yes: true,
+            checkRunningProcesses: true,
+            showProgress: true
+        };
+        console.log(args.dryRun ? '\n[DRY RUN] No files will be deleted\n' : '\n');
+        const deleteResult = await deleteSelectedNodeModules(items, options);
+        console.log(`\n${'─'.repeat(80)}`);
+        console.log(`Deleted: ${deleteResult.successful}/${deleteResult.totalAttempted}`);
+        console.log(`Space ${args.dryRun ? 'that would be' : ''} freed: ${deleteResult.formattedBytesFreed}`);
+        if (deleteResult.failed > 0) {
+            console.log(`Failed: ${deleteResult.failed}`);
+            process.exit(1);
+        }
+    } catch (error) {
+        console.error('Operation failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+/**
+ * Main entry point.
+ * Parses arguments and routes to appropriate mode.
+ */ async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        showHelp();
+        process.exit(0);
+    }
+    if (args.version) {
+        showVersion();
+        process.exit(0);
+    }
+    if (args.auto) {
+        await runAutoDelete(args);
+        process.exit(0);
+    }
+    if (args.scan) {
+        await runQuickScan(args);
+        process.exit(0);
+    }
+    // Interactive TUI mode (default)
+    const { waitUntilExit } = render(/*#__PURE__*/ React.createElement(App, {
+        rootPath: args.path
+    }));
+    await waitUntilExit();
+}
+// Run main and handle errors
+main().catch((error)=>{
+    console.error('Fatal error:', error);
+    process.exit(1);
+});