mod caches;
mod cleaner;
mod config;
mod deps;
mod output;
mod project;
mod utils;
use anyhow::{Context, Result};
use clap::Parser;
use colored::control;
use colored::Colorize;
use cleaner::{clean_project, compute_target_sizes, CleanResult};
use config::{load_config, resolve_settings};
use deps::clean_dependencies;
use output::{create_progress_bars, create_project_progress_bar, print_error, print_summary, print_verbose_cleaned, Summary};
use project::find_cargo_projects;
use rayon::prelude::*;
use std::collections::HashMap;
use std::io::{self, BufRead, Write};
use std::path::{Path, PathBuf};
use utils::parse_size;
#[derive(Parser, Debug)]
#[command(name = "cargo-deepclean")]
#[command(about = "Recursively clean Cargo projects with workspace support", long_about = None)]
#[command(bin_name = "cargo deepclean")]
struct Args {
#[arg(default_value = ".")]
directory: std::path::PathBuf,
#[arg(long)]
dry_run: bool,
#[arg(short = 'e', long = "exclude")]
exclude_patterns: Vec<String>,
#[arg(short = 'j', long = "jobs")]
jobs: Option<usize>,
#[arg(short, long)]
verbose: bool,
#[arg(long)]
json: bool,
#[arg(long)]
min_size: Option<String>,
#[arg(long)]
clean_deps: bool,
#[arg(long)]
remove_deps: bool,
#[arg(long)]
interactive: bool,
#[arg(long)]
caches: bool,
#[arg(long, requires = "caches")]
all: bool,
}
fn parse_args_from(args: Vec<String>) -> Args {
let mut args_iter = args.into_iter();
let program_name = args_iter.next();
let first_arg = args_iter.next();
if first_arg.as_deref() == Some("deepclean") {
let prog = program_name.unwrap_or_else(|| "cargo-deepclean".to_string());
let rest: Vec<String> = std::iter::once(prog).chain(args_iter).collect();
Args::parse_from(rest)
} else {
let mut all_args = vec![program_name.unwrap_or_else(|| "cargo-deepclean".to_string())];
if let Some(arg) = first_arg {
all_args.push(arg);
}
all_args.extend(args_iter);
Args::parse_from(all_args)
}
}
fn parse_args() -> Args {
parse_args_from(std::env::args().collect())
}
fn relative_display(path: &Path, root: &Path) -> String {
match path.strip_prefix(root) {
Ok(rel) if rel.as_os_str().is_empty() => ".".to_string(),
Ok(rel) => rel.display().to_string(),
Err(_) => path.display().to_string(),
}
}
fn confirm_interactive(
projects: &[project::Project],
dry_run: bool,
target_sizes: &HashMap<PathBuf, u64>,
root: &Path,
) -> Result<bool> {
println!();
println!(
"{} Found {} project(s) to clean:",
"[INFO]".blue().bold(),
projects.len()
);
for project in projects {
let target_dir = project.path.join("target");
let size = target_sizes.get(&target_dir).copied().unwrap_or(0);
println!(
" • {} ({})",
relative_display(&project.path, root),
utils::format_bytes(size)
);
}
if dry_run {
println!(
"{} Dry run mode: no changes will be made if you continue.",
"[INFO]".yellow().bold()
);
}
print!(
"{} Proceed with cleaning? [y/N]: ",
"[PROMPT]".cyan().bold()
);
io::stdout().flush()?;
let mut line = String::new();
io::stdin().lock().read_line(&mut line)?;
Ok(matches!(line.trim().to_ascii_lowercase().as_str(), "y" | "yes"))
}
fn main() -> Result<()> {
let args = parse_args();
if args.caches {
return caches::run_cache_mode(args.dry_run, args.json, args.all);
}
let config = load_config(&args.directory)
.context("Failed to load configuration. Check .deepclean.toml syntax and permissions.")?;
let settings = resolve_settings(
config.as_ref(),
&args.exclude_patterns,
args.jobs,
args.min_size.as_deref(),
args.json,
);
control::set_override(settings.use_color);
let root = args
.directory
.canonicalize()
.with_context(|| {
format!(
"Failed to resolve directory {:?}. \
Ensure the path exists and you have permission to read it.",
args.directory
)
})?;
if !settings.json {
println!(
"{} Starting cargo clean from: {:?}",
"[INFO]".blue().bold(),
root
);
println!(
"{} Searching for Cargo projects...",
"[INFO]".blue().bold()
);
}
rayon::ThreadPoolBuilder::new()
.num_threads(settings.jobs)
.build_global()
.context("Failed to configure parallel job count")?;
let projects = find_cargo_projects(&root, &settings.exclude_patterns)
.context("Failed to find Cargo projects while scanning the directory tree")?;
if projects.is_empty() {
if !settings.json {
println!(
"{} No Cargo projects found",
"[WARNING]".yellow().bold()
);
}
return Ok(());
}
let min_size_bytes = if let Some(ref min_size_str) = settings.min_size {
Some(parse_size(min_size_str).with_context(|| {
format!(
"Invalid min-size value '{}'. Expected a size like '100MB', '1GB', or '500KB'.",
min_size_str
)
})?)
} else {
None
};
let needs_sizes = min_size_bytes.is_some() || args.interactive || args.dry_run;
let target_sizes: HashMap<PathBuf, u64> = if needs_sizes {
compute_target_sizes(&projects)
} else {
HashMap::new()
};
let projects: Vec<_> = if let Some(min_bytes) = min_size_bytes {
projects
.iter()
.filter(|project| {
let target_dir = project.path.join("target");
target_sizes.get(&target_dir).copied().unwrap_or(0) >= min_bytes
})
.cloned()
.collect()
} else {
projects
};
if projects.is_empty() {
if !settings.json {
if min_size_bytes.is_some() {
println!(
"{} No projects found above the minimum size threshold",
"[INFO]".blue().bold()
);
} else {
println!(
"{} No Cargo projects found",
"[WARNING]".yellow().bold()
);
}
}
return Ok(());
}
if args.interactive && !confirm_interactive(&projects, args.dry_run, &target_sizes, &root)? {
if !settings.json {
println!("{} Cancelled by user", "[INFO]".blue().bold());
}
return Ok(());
}
if !settings.json {
println!(
"{} Found {} project(s)",
"[INFO]".blue().bold(),
projects.len()
);
if args.dry_run {
println!(
"{} DRY RUN MODE - no changes will be made",
"[INFO]".yellow().bold()
);
}
let clean_deps = args.clean_deps || args.remove_deps;
if clean_deps {
println!(
"{} Dependency cleaning enabled (native detection)",
"[INFO]".blue().bold()
);
if args.remove_deps {
println!(
"{} Will remove unused dependencies (requires cargo-remove)",
"[INFO]".yellow().bold()
);
}
}
println!();
}
let (multi, overall_pb) =
create_progress_bars(projects.len(), !settings.json && !args.verbose);
let results: Vec<CleanResult> = projects
.par_iter()
.with_min_len(1)
.map(|project| {
let project_pb = multi
.as_ref()
.map(|multi| create_project_progress_bar(multi, &project.path));
if args.verbose && !settings.json {
println!(
"{} Cleaning: {}",
"[INFO]".blue().bold(),
relative_display(&project.path, &root)
);
}
let cached_size = target_sizes
.get(&project.path.join("target"))
.copied();
let mut result = clean_project(project, args.dry_run, args.verbose, cached_size);
if args.clean_deps || args.remove_deps {
let deps_result =
clean_dependencies(project, args.dry_run, args.remove_deps, args.verbose);
match deps_result {
Ok(deps_clean) => {
if let Ok(ref mut r) = result {
r.unused_deps = deps_clean.unused_deps.clone();
}
if !deps_clean.unused_deps.is_empty() {
if !settings.json {
println!(
"{} Found {} unused dependency(ies) in {}:",
"[INFO]".blue().bold(),
deps_clean.unused_deps.len(),
project.path.display()
);
for dep in &deps_clean.unused_deps {
println!(
" {} {} ({})",
"•".yellow(),
dep.name.bright_yellow(),
dep.location
);
}
if deps_clean.removed_count > 0 {
println!(
"{} Removed {} unused dependency(ies)",
"[SUCCESS]".green().bold(),
deps_clean.removed_count
);
} else if args.remove_deps && !args.dry_run {
if let Some(ref error) = deps_clean.error {
println!(
"{} Failed to remove dependencies: {}. \
Install cargo-edit with `cargo install cargo-edit`.",
"[ERROR]".red().bold(),
error
);
} else {
println!(
"{} Could not remove dependencies. \
Install cargo-remove with `cargo install cargo-edit`.",
"[WARNING]".yellow().bold()
);
}
} else if args.dry_run {
println!(
"{} Would remove {} dependency(ies) (use --remove-deps to actually remove)",
"[INFO]".blue().bold(),
deps_clean.unused_deps.len()
);
}
}
} else if !settings.json && args.verbose {
println!(
"{} No unused dependencies found in {}",
"[INFO]".blue().bold(),
project.path.display()
);
}
if let Some(ref error) = deps_clean.error
&& !settings.json
{
println!(
"{} Error during dependency removal in {:?}: {}",
"[ERROR]".red().bold(),
project.path,
error
);
}
}
Err(e) => {
if !settings.json {
println!(
"{} Failed to check dependencies in {:?}: {}",
"[WARNING]".yellow().bold(),
project.path,
e
);
}
}
}
}
if let Some(ref pb) = project_pb {
let project_name = project
.path
.file_name()
.and_then(|n| n.to_str())
.map(|s| s.to_string())
.unwrap_or_else(|| project.path.to_string_lossy().to_string());
pb.finish_with_message(format!("✓ {}", project_name));
}
if let Some(ref overall) = overall_pb {
overall.inc(1);
}
match result {
Ok(r) => {
if args.verbose && !settings.json {
print_verbose_cleaned(&r);
}
Ok(r)
}
Err(e) => {
let error_msg = e.to_string();
if !settings.json {
print_error(&project.path, &error_msg);
}
Ok(CleanResult {
path: project.path.to_string_lossy().to_string(),
success: false,
freed_bytes: 0,
error: Some(error_msg),
unused_deps: Vec::new(),
})
}
}
})
.collect::<Result<Vec<_>>>()?;
if let Some(ref overall) = overall_pb {
overall.finish_with_message("All projects completed!");
}
let cleaned = results.iter().filter(|r| r.success).count();
let failed = results.len() - cleaned;
let total_freed: u64 = results.iter().map(|r| r.freed_bytes).sum();
let summary = Summary {
total_projects: projects.len(),
cleaned,
failed,
total_freed_bytes: total_freed,
results,
};
if settings.json {
println!("{}", serde_json::to_string_pretty(&summary)?);
} else {
print_summary(&summary);
}
if failed > 0 {
std::process::exit(1);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn args(items: &[&str]) -> Vec<String> {
items.iter().map(|s| s.to_string()).collect()
}
#[test]
fn test_parse_args_from_direct_invocation_flags() {
let a = parse_args_from(args(&["cargo-deepclean", "--dry-run", "--json"]));
assert!(a.dry_run);
assert!(a.json);
assert_eq!(a.directory, PathBuf::from("."));
}
#[test]
fn test_parse_args_from_subcommand_path_preserves_first_flag() {
let a = parse_args_from(args(&["cargo", "deepclean", "--dry-run"]));
assert!(a.dry_run, "first flag after `deepclean` must be preserved");
assert_eq!(a.directory, PathBuf::from("."));
}
#[test]
fn test_parse_args_from_subcommand_path_with_flags() {
let a = parse_args_from(args(&[
"cargo",
"deepclean",
"--verbose",
"--min-size",
"100MB",
]));
assert!(a.verbose);
assert_eq!(a.min_size.as_deref(), Some("100MB"));
}
#[test]
fn test_parse_args_from_positional_directory() {
let a = parse_args_from(args(&["cargo-deepclean", "some/dir", "--dry-run"]));
assert_eq!(a.directory, PathBuf::from("some/dir"));
assert!(a.dry_run);
}
#[test]
fn test_parse_args_from_subcommand_with_directory_and_jobs() {
let a = parse_args_from(args(&["cargo", "deepclean", "/tmp/x", "-j", "4"]));
assert_eq!(a.directory, PathBuf::from("/tmp/x"));
assert_eq!(a.jobs, Some(4));
}
#[test]
fn test_parse_args_from_defaults() {
let a = parse_args_from(args(&["cargo-deepclean"]));
assert!(!a.dry_run);
assert!(!a.json);
assert!(!a.verbose);
assert!(!a.caches);
assert!(!a.interactive);
assert!(a.exclude_patterns.is_empty());
assert!(a.jobs.is_none());
assert_eq!(a.directory, PathBuf::from("."));
}
#[test]
fn test_parse_args_from_subcommand_caches_flag() {
let a = parse_args_from(args(&["cargo", "deepclean", "--caches", "--dry-run"]));
assert!(a.caches);
assert!(a.dry_run);
}
#[test]
fn test_parse_args_from_subcommand_caches_all() {
let a = parse_args_from(args(&["cargo", "deepclean", "--caches", "--all"]));
assert!(a.caches);
assert!(a.all);
}
#[test]
fn test_parse_args_all_requires_caches_flag() {
let result = Args::try_parse_from(["cargo-deepclean", "--all"]);
assert!(result.is_err(), "--all alone should fail arg parsing");
}
#[test]
fn test_relative_display_nested_project() {
let root = Path::new("/repo");
assert_eq!(
relative_display(Path::new("/repo/services/api"), root),
"services/api"
);
}
#[test]
fn test_relative_display_root_itself_shows_dot() {
let root = Path::new("/repo");
assert_eq!(relative_display(root, root), ".");
}
#[test]
fn test_relative_display_falls_back_when_outside_root() {
let root = Path::new("/repo");
assert_eq!(
relative_display(Path::new("/other/place"), root),
"/other/place"
);
}
#[test]
fn test_parse_args_from_short_excludes_repeated() {
let a = parse_args_from(args(&[
"cargo-deepclean",
"-e",
"node_modules",
"-e",
"**/vendor",
]));
assert_eq!(a.exclude_patterns, vec!["node_modules", "**/vendor"]);
}
}