clean-dev-dirs-2.2.0 has been yanked.

🧹 clean-dev-dirs

A fast and efficient CLI tool for recursively cleaning Rust target/, Node.js node_modules/, Python cache, and Go vendor/ directories to reclaim disk space.

Quick Start

# Install from crates.io
cargo install clean-dev-dirs

# Clean all development directories in current directory
clean-dev-dirs

# Preview what would be cleaned (dry run)
clean-dev-dirs --dry-run

# Interactive mode - choose which projects to clean
clean-dev-dirs --interactive

Features

Multi-language support: Clean Rust (target/), Node.js (node_modules/), Python (cache dirs), and Go (vendor/) build artifacts
Executable preservation: Optionally keep compiled binaries while removing build artifacts
Parallel scanning: Lightning-fast directory traversal using multithreading
Smart filtering: Filter by project size, modification time, and project type
Interactive mode: Choose which projects to clean with an intuitive interface
Dry-run mode: Preview what would be cleaned without actually deleting anything
Progress indicators: Real-time feedback during scanning and cleaning operations
Detailed statistics: See total space that can be reclaimed before cleaning
Flexible configuration: Combine multiple filters and options for precise control

Inspiration

This project is inspired by cargo-clean-all, a Rust-specific tool for cleaning cargo projects. We've improved upon the original concept with:

Multi-language support: Extended beyond Rust to support Node.js, Python, and Go projects
Parallel scanning: Significantly faster directory traversal using multithreading
Enhanced filtering: More granular control over what gets cleaned
Cleaner code architecture: Well-structured, modular codebase for better maintainability

Installation

From crates.io (Recommended)

cargo install clean-dev-dirs

From Source

git clone https://github.com/TomPlanche/clean-dev-dirs.git
cd clean-dev-dirs
cargo install --path .

Requirements

Rust 2021 edition or later
Cargo package manager

Usage

Basic Usage

# Clean all development directories in the current directory
clean-dev-dirs

# Clean a specific directory
clean-dev-dirs ~/Projects

# Preview what would be cleaned (dry run)
clean-dev-dirs --dry-run

# Interactive mode - choose which projects to clean
clean-dev-dirs --interactive

Project Type Filtering

# Clean only Rust projects
clean-dev-dirs --project-type rust
# or use short flag
clean-dev-dirs -p rust

# Clean only Node.js projects
clean-dev-dirs -p node

# Clean only Python projects
clean-dev-dirs -p python

# Clean only Go projects
clean-dev-dirs -p go

# Clean all project types (default)
clean-dev-dirs -p all

Size and Time Filtering

# Only clean projects with build dirs larger than 100MB
clean-dev-dirs --keep-size 100MB

# Only clean projects not modified in the last 30 days
clean-dev-dirs --keep-days 30

# Combine size and time filters
clean-dev-dirs --keep-size 50MB --keep-days 7

Advanced Options

# Use 8 threads for faster scanning
clean-dev-dirs --threads 8

# Show verbose output including scan errors
clean-dev-dirs --verbose

# Skip specific directories during scanning
clean-dev-dirs --skip node_modules --skip .git

# Non-interactive mode (auto-confirm)
clean-dev-dirs --yes

# Keep compiled executables (preserves binaries while cleaning build artifacts)
clean-dev-dirs --keep-executables

# Combine multiple options
clean-dev-dirs ~/Projects -p rust --keep-size 100MB --keep-days 30 --dry-run

Common Use Cases

1. Clean old Rust projects:

clean-dev-dirs ~/Projects -p rust --keep-days 90

2. Preview large Python cache directories:

clean-dev-dirs ~/workspace -p python --keep-size 50MB --dry-run

3. Interactive cleaning of all Node.js projects:

clean-dev-dirs ~/dev -p node --interactive

4. Quick cleanup with confirmation:

clean-dev-dirs ~/code --keep-size 100MB --keep-days 60

5. Fast scan with multiple threads:

clean-dev-dirs /large/directory --threads 16 --verbose

6. Clean while preserving executables:

clean-dev-dirs ~/rust-projects -p rust --keep-executables

Command Reference

Main Arguments

Argument	Description
`[DIR]`	Directory to search for projects (default: current directory)

Project Type Filter

Option	Short	Values	Description
`--project-type`	`-p`	`all`, `rust`, `node`, `python`, `go`	Filter by project type (default: `all`)

Filtering Options

Option	Short	Description
`--keep-size`	`-s`	Ignore projects with build dir smaller than specified size
`--keep-days`	`-d`	Ignore projects modified in the last N days

Execution Options

Option	Short	Description
`--yes`	`-y`	Don't ask for confirmation; clean all detected projects
`--dry-run`		List cleanable projects without actually cleaning
`--interactive`	`-i`	Use interactive project selection
`--keep-executables`	`-k`	Preserve compiled binaries while removing build artifacts

Scanning Options

Option	Short	Description
`--threads`	`-t`	Number of threads for directory scanning (default: CPU cores)
`--verbose`	`-v`	Show access errors during scanning
`--skip`		Directories to skip during scanning (can be specified multiple times)

Size Formats

The --keep-size option supports various size formats:

Format	Example	Description
Decimal	`100KB`, `1.5MB`, `2GB`	Base 1000
Binary	`100KiB`, `1.5MiB`, `2GiB`	Base 1024
Bytes	`1000000`	Raw byte count

Examples:

clean-dev-dirs --keep-size 100KB    # 100 kilobytes
clean-dev-dirs --keep-size 1.5MB    # 1.5 megabytes
clean-dev-dirs --keep-size 2GiB     # 2 gibibytes
clean-dev-dirs --keep-size 500000   # 500,000 bytes

Project Detection

The tool automatically detects development projects by looking for characteristic files and directories:

Rust Projects

Detection criteria: Both Cargo.toml and target/ directory must exist
Cleans: target/ directory
Name extraction: From [package] name in Cargo.toml

Node.js Projects

Detection criteria: Both package.json and node_modules/ directory must exist
Cleans: node_modules/ directory
Name extraction: From name field in package.json

Python Projects

Detection criteria:
- At least one config file: requirements.txt, setup.py, pyproject.toml, setup.cfg, Pipfile, pipenv.lock, poetry.lock
- At least one cache/build directory exists
Cleans: The largest cache/build directory among:
- __pycache__
- .pytest_cache
- venv / .venv
- build / dist
- .eggs / .tox / .coverage
Name extraction: From pyproject.toml (project name or tool.poetry name) or setup.py

Go Projects

Detection criteria: Both go.mod and vendor/ directory must exist
Cleans: vendor/ directory
Name extraction: From module path in go.mod

Executable Preservation

The --keep-executables flag allows you to reclaim disk space from build artifacts while preserving your compiled binaries. This is particularly useful when:

You want to free up space but keep your working executables
You're cleaning projects you're actively developing
You want to avoid recompiling release binaries

How It Works

For Rust Projects:

Scans target/debug/ and target/release/ for executable files
Backs up executables to a temporary location
Removes the entire target/ directory
Restores executables to their original locations
Example: Keeps target/release/my-app but removes all dependencies and intermediate artifacts

For Go Projects:

Preserves executable files in the vendor/bin/ directory
Removes all other vendor dependencies
Note: Most Go projects don't store executables in the vendor directory

For Node.js and Python Projects:

No effect (these languages don't produce standalone compiled executables)

Example Usage

# Clean Rust projects but keep release binaries
clean-dev-dirs ~/rust-workspace -p rust --keep-executables

# Interactive cleaning with executable preservation
clean-dev-dirs --interactive --keep-executables

# Combine with other filters
clean-dev-dirs --keep-executables --keep-days 30 --keep-size 100MB

Safety Features

Dry-run mode: Preview all operations before execution with --dry-run
Interactive confirmation: Manually select projects to clean with --interactive
Intelligent filtering: Skip recently modified or small projects with --keep-days and --keep-size
Executable preservation: Keep compiled binaries with --keep-executables
Error handling: Graceful handling of permission errors and inaccessible files
Read-only scanning: Never modifies files during the scanning phase
Clear output: Color-coded, human-readable output with project types and sizes

Output

The tool provides beautiful, colored output including:

Icon	Project Type
🦀	Rust projects
📦	Node.js projects
🐍	Python projects
🐹	Go projects

Sample Output

Found 15 projects

📊 Found projects:

🦀 my-rust-app (/home/user/projects/rust-app)
   Size: 2.3 GB

📦 web-frontend (/home/user/projects/web-app)
   Size: 856 MB

🐍 ml-project (/home/user/projects/python-ml)
   Size: 1.2 GB

Total space that can be reclaimed: 4.4 GB

Contributing

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

Adding Language Support

Want to add support for a new programming language? Here's how to extend clean-dev-dirs:

1. Update Project Types

First, add your language to the ProjectType enum in src/project/project.rs:

#[derive(Clone, PartialEq, Debug)]
pub enum ProjectType {
    Rust,
    Node,
    Python,
    Go,
    YourLanguage, // Add your language here
}

Don't forget to update the Display implementation to include an appropriate emoji and name.

2. Add CLI Filter Option

Update src/config/filter.rs to add your language to the ProjectFilter enum:

#[derive(Clone, Copy, PartialEq, Debug, ValueEnum, Default)]
pub enum ProjectFilter {
    All,
    Rust,
    Node,
    Python,
    Go,
    YourLanguage, // Add here
}

3. Implement Project Detection

Add detection logic in src/scanner.rs by implementing:

Detection method: detect_your_language_project() - identifies projects by looking for characteristic files
Name extraction: extract_your_language_project_name() - parses project configuration files to get the name
Integration: Update detect_project() to call your detection method

Example detection criteria:

fn detect_your_language_project(&self, path: &Path, errors: &Arc<Mutex<Vec<String>>>) -> Option<Project> {
    let config_file = path.join("your_config.conf");  // Language-specific config file
    let build_dir = path.join("build");               // Build/cache directory to clean

    if config_file.exists() && build_dir.exists() {
        let name = self.extract_your_language_project_name(&config_file, errors);

        let build_arts = BuildArtifacts {
            path: build_dir,
            size: 0, // Will be calculated later
        };

        return Some(Project::new(
            ProjectType::YourLanguage,
            path.to_path_buf(),
            build_arts,
            name,
        ));
    }

    None
}

4. Update Directory Exclusions

Add any language-specific directories that should be skipped during scanning to the should_scan_entry() method in src/scanner.rs.

5. Update Documentation

Add your language to the "Project Detection" section in this README
Update the CLI help text descriptions
Add examples in the usage section

6. Testing Considerations

Consider these when testing your implementation:

Multiple config files: Some languages have different project file formats
Build directory variations: Different build tools may use different directory names
Name extraction edge cases: Handle malformed or missing project names gracefully
Performance: Ensure detection doesn't significantly slow down scanning

7. Example Languages to Add

Some languages that would be great additions:

C/C++: Look for CMakeLists.txt/Makefile + build/ or cmake-build-*/
Java: Look for pom.xml/build.gradle + target/ or build/
C#: Look for *.csproj/*.sln + bin//obj/
PHP: Look for composer.json + vendor/
Ruby: Look for Gemfile + vendor/bundle/
Swift: Look for Package.swift + .build/

8. Pull Request Guidelines

When submitting your language support:

Test thoroughly: Verify detection works with real projects
Add examples: Include sample project structures in your PR description
Update help text: Ensure all user-facing text is clear and consistent
Follow patterns: Use the same patterns as existing language implementations
Consider edge cases: Handle projects with unusual structures gracefully

License

This project is dual-licensed under either:

MIT License - see the LICENSE-MIT file for details
Apache License 2.0 - see the LICENSE-APACHE file for details

You may choose either license at your option.

Acknowledgments

Built with excellent open-source libraries:

Clap - Command-line argument parsing with derive macros
Rayon - Data parallelism for fast directory scanning
Colored - Beautiful colored terminal output
Indicatif - Progress bars and spinners
Inquire - Interactive prompts and selection
WalkDir - Recursive directory iteration
Humansize - Human-readable file sizes

Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Crates.io: clean-dev-dirs

clean-dev-dirs 2.2.0