null-e 🤖

     .---.
    |o   o|    null-e
    |  ^  |    ═══════════════════════════════════
    | === |    The friendly disk cleanup robot
    `-----'    Send your cruft to /dev/null!
     /| |\

The Friendly Disk Cleanup Robot - Inspired by Wall-E, powered by Rust.

null-e helps developers reclaim disk space by finding and cleaning development artifacts, caches, and unused files. It can detect and clean 100+ GB of reclaimable space across your system.

Why "null-e"?

/dev/null + Wall-E = null-e 🤖

Like the adorable trash-compacting robot from the movie, null-e tirelessly cleans up your developer junk and sends it where it belongs - to /dev/null!

What Can null-e Clean?

Features

• Multi-language Support: Node.js, Rust, Python, Go, Java, .NET, Swift, Ruby, PHP, and more
• Git Protection: Never accidentally delete uncommitted changes
• Safe Deletion: Moves to trash by default with recovery option
• Parallel Scanning: Fast directory traversal using multiple threads
• Analysis Tools: Find stale projects, duplicate dependencies, optimize git repos
• Beautiful CLI: Colored output with progress indicators
• Cross-Platform: macOS, Linux, Windows support

Installation

From Source

git clone https://github.com/us/null-e.git
cd null-e
cargo install --path .

Using Cargo

cargo install null-e

Using Homebrew (macOS)

brew tap us/tap
brew install null-e

Quick Start

# Scan current directory for cleanable artifacts
null-e

# Deep sweep - find ALL cleanable items across your system
null-e sweep

# Clean global developer caches (npm, pip, cargo, etc.)
null-e caches

# Analyze git repositories for optimization
null-e git-analyze ~/projects

# Find stale projects not touched in 6 months
null-e stale ~/projects

# Find duplicate dependencies
null-e duplicates ~/projects

Commands Overview

Core Commands

Specialized Cleaners

Analysis Tools

Usage Examples

Basic Scanning

# Scan current directory
null-e

# Scan specific directories
null-e ~/projects ~/work

# Scan with depth limit
null-e -d 5 ~/projects

# Filter by minimum size
null-e -s 100MB ~/projects

# Show all results (no limit)
null-e -a ~/projects

# Verbose output
null-e -v ~/projects

Deep Sweep

# Find everything cleanable
null-e sweep

# Filter by category
null-e sweep --category xcode
null-e sweep --category docker

# Clean interactively
null-e sweep --clean

Global Caches

# Show all global caches
null-e caches

# Clean selected caches interactively
null-e caches --clean

# Clean all caches
null-e caches --clean-all

Xcode Cleanup

# Show Xcode artifacts
null-e xcode

# Clean DerivedData, old simulators, etc.
null-e xcode --clean

Docker Cleanup

# Show Docker resources
null-e docker

# Clean (excluding volumes)
null-e docker --clean

# Clean including volumes (careful!)
null-e docker --clean --volumes

Git Analysis

# Analyze git repos in a directory
null-e git-analyze ~/projects

# Run git gc on repos that need it
null-e git-analyze ~/projects --fix

# Dry run
null-e git-analyze ~/projects --fix --dry-run

Stale Project Detection

# Find projects not touched in 180 days (default)
null-e stale ~/projects

# Custom threshold (90 days)
null-e stale --days 90 ~/projects

# Clean build artifacts from stale projects
null-e stale --days 90 --clean ~/projects

Duplicate Detection

# Find duplicate dependencies
null-e duplicates ~/projects

# Verbose output with details
null-e duplicates -v ~/projects

Protection Levels

null-e protects your uncommitted work:

# Warn about uncommitted changes (default)
null-e clean -p warn

# Block cleaning repos with uncommitted changes
null-e clean -p block

# No protection (dangerous!)
null-e clean -p none

# Paranoid mode - require confirmation for everything
null-e clean -p paranoid

Deletion Methods

# Move to trash (default, safe)
null-e clean -m trash

# Permanent delete (careful!)
null-e clean -m permanent

# Dry run (no deletion)
null-e clean -m dry-run
# or
null-e clean -n

Configuration

Create ~/.config/null-e/config.toml:

[general]
default_paths = ["~/projects", "~/work"]
verbose = false

[scan]
max_depth = 10
skip_hidden = true
min_size = 1000000  # 1 MB

[clean]
delete_method = "trash"
protection_level = "warn"

[ui]
use_icons = true
sort_by = "size"

Config Commands

# Show current config
null-e config

# Initialize config file
null-e config --init

# Show config path
null-e config --path

Project Types Supported

Safety Levels

Each cleanable item has a safety level:

Architecture

     .---.
    |o   o|
    |  ^  |    ┌──────────────────────────────────────────────────┐
    | === |    │                       CLI                         │
    `-----'    ├──────────────────────────────────────────────────┤
     /| |\     │                    Core Engine                    │
               │  ┌──────────┐  ┌──────────┐  ┌──────────┐        │
               │  │ Scanner  │  │ Cleaner  │  │ Analysis │        │
               │  │          │  │          │  │  Tools   │        │
               │  └──────────┘  └──────────┘  └──────────┘        │
               ├──────────────────────────────────────────────────┤
               │                    Modules                        │
               │  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐     │
               │  │Plugins │ │Cleaners│ │ Caches │ │ Docker │     │
               │  │(langs) │ │(system)│ │(global)│ │        │     │
               │  └────────┘ └────────┘ └────────┘ └────────┘     │
               └──────────────────────────────────────────────────┘

Documentation

Detailed documentation for each module:

• Cleaners Guide - System cleaners (Xcode, Docker, etc.)
• Caches Guide - Global cache management
• Analysis Guide - Analysis tools (git, stale, duplicates)

Development

Building

# Debug build
cargo build

# Release build
cargo build --release

# Run tests
cargo test

# Run with logging
RUST_LOG=debug cargo run

Project Structure

src/
├── main.rs           # CLI entry point
├── lib.rs            # Library exports
├── analysis/         # Analysis tools
│   ├── git.rs        # Git repository analysis
│   ├── stale.rs      # Stale project detection
│   └── duplicates.rs # Duplicate dependency detection
├── caches/           # Global cache management
├── cleaners/         # System cleaners
│   ├── xcode.rs      # Xcode cleaner
│   ├── android.rs    # Android cleaner
│   ├── docker.rs     # Docker cleaner
│   ├── ml.rs         # ML/AI cleaner
│   ├── ide.rs        # IDE cleaner
│   ├── homebrew.rs   # Homebrew cleaner
│   ├── ios_deps.rs   # iOS dependencies cleaner
│   ├── electron.rs   # Electron apps cleaner
│   ├── gamedev.rs    # Game development cleaner
│   ├── cloud.rs      # Cloud CLI cleaner
│   ├── macos.rs      # macOS system cleaner
│   └── logs.rs       # Log cleaner
├── plugins/          # Language plugins
├── core/             # Core scanning/cleaning logic
├── docker/           # Docker integration
├── git/              # Git integration
├── trash/            # Trash/delete operations
└── config/           # Configuration management

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Adding a New Cleaner

1. Create a new file in src/cleaners/
2. Implement the cleaner with detect() method
3. Add to src/cleaners/mod.rs
4. Add CLI command in src/main.rs
5. Add tests

Adding a New Plugin

1. Create a new file in src/plugins/
2. Implement the Plugin trait
3. Register in src/plugins/mod.rs
4. Add tests

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• Inspired by Wall-E (the adorable trash robot!)
• Also inspired by npkill and kondo
• Built with Rust

     .---.
    |o   o|   "Directive: Clean all the things!"
    |  ^  |
    | === |   Made with 💚 for developers who need their disk space back.
    `-----'
     /| |\