Workspace Discovery

apps/dustfril-cli/src/cli.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use clap::{Args, Parser, Subcommand};
 
 /// DustFril CLI
@@ -12,17 +14,29 @@ pub struct Cli {
 #[derive(Subcommand)]
 pub enum Commands {
     /// Scan Rust artifacts
-    Scan,
+    Scan(PathArgs),
 
     /// Analyze disk usage
-    Analyze,
+    Analyze(PathArgs),
 
     /// Clean artifacts
     Clean(CleanArgs),
 }
 
+#[derive(Args)]
+pub struct PathArgs {
+    pub path: Option<PathBuf>,
+
+    /// Scan the entire system instead of a specific workspace.
+    #[arg(long)]
+    pub global: bool,
+}
+
 #[derive(Args)]
 pub struct CleanArgs {
+    #[command(flatten)]
+    pub path_args: PathArgs,
+
     // Preview cleanup operations without deleting files.
     #[arg(long)]
     pub dry_run: bool,

apps/dustfril-cli/src/commands/analyze.rs

@@ -1,8 +1,8 @@
-use std::path::Path;
-
+use dustfril_core::models::{AnalysisResult, CleanupRecommendation};
 use dustfril_core::{analyzer, detector};
 
-use dustfril_core::models::{AnalysisResult, CleanupRecommendation};
+use crate::cli::PathArgs;
+use crate::shared::path::{resolve_path, validate_path};
 
 fn print_summary(analysis: &AnalysisResult) {
     let mut keep = 0;
@@ -55,8 +55,18 @@ fn print_summary(analysis: &AnalysisResult) {
     println!("\n----------------------------------------\n");
 }
 
-pub fn execute() {
-    let scan_result = detector::scan(Path::new("."));
+pub fn execute(args: PathArgs) {
+    let path = resolve_path(&args.path);
+
+    if !validate_path(&path) {
+        return;
+    }
+
+    let scan_result = if args.global {
+        detector::scan_global()
+    } else {
+        detector::scan_workspace(&path)
+    };
 
     let analysis_result = analyzer::analyze(scan_result);
 

apps/dustfril-cli/src/commands/clean.rs

@@ -1,13 +1,13 @@
-use std::path::Path;
-
 use dustfril_core::{
     analyzer, cleaner, detector,
     models::{CleanupPlan, CleanupResult},
 };
 
+use crate::{cli::CleanArgs, shared::path::resolve_path};
+
 // dry-run
-pub fn dry_run() {
-    let plan = build_cleanup_plan();
+pub fn dry_run(args: &CleanArgs) {
+    let plan = build_cleanup_plan(args);
 
     if plan.candidates.is_empty() {
         println!("No cleanup candidates found.");
@@ -22,8 +22,14 @@ pub fn dry_run() {
 
 use std::io::{self, Write};
 
-fn build_cleanup_plan() -> CleanupPlan {
-    let scan_result = detector::scan(Path::new("."));
+fn build_cleanup_plan(args: &CleanArgs) -> CleanupPlan {
+    let path = resolve_path(&args.path_args.path);
+
+    let scan_result = if args.path_args.global {
+        detector::scan_global()
+    } else {
+        detector::scan_workspace(&path)
+    };
 
     let analysis = analyzer::analyze(scan_result);
 
@@ -71,7 +77,7 @@ fn print_cleanup_result(result: &CleanupResult) {
 
     println!("Failed: {}", result.failed_paths.len());
 
-    println!("Freed: {}", analyzer::format_size(result.freed_size_bytes,));
+    println!("Freed: {}", analyzer::format_size(result.freed_size_bytes));
 
     if !result.deleted_paths.is_empty() {
         println!("Deleted\n");
@@ -84,8 +90,8 @@ fn print_cleanup_result(result: &CleanupResult) {
     }
 }
 
-pub fn execute() {
-    let plan = build_cleanup_plan();
+pub fn execute(args: &CleanArgs) {
+    let plan = build_cleanup_plan(args);
 
     if plan.candidates.is_empty() {
         println!("No cleanup candidates found.");

apps/dustfril-cli/src/commands/scan.rs

@@ -1,9 +1,22 @@
-use std::path::Path;
-
 use dustfril_core::detector;
 
-pub fn execute() {
-    let result = detector::scan(Path::new("."));
+use crate::{
+    cli::PathArgs,
+    shared::path::{resolve_path, validate_path},
+};
+
+pub fn execute(args: PathArgs) {
+    let path = resolve_path(&args.path);
+
+    if !validate_path(&path) {
+        return;
+    }
+
+    let result = if args.global {
+        detector::scan_global()
+    } else {
+        detector::scan_workspace(&path)
+    };
 
     if result.artifacts.is_empty() {
         println!("No Rust artifacts found.");

apps/dustfril-cli/src/main.rs

@@ -1,5 +1,6 @@
 mod cli;
 mod commands;
+mod shared;
 
 use clap::Parser;
 
@@ -9,19 +10,19 @@ fn main() {
     let cli = Cli::parse();
 
     match cli.command {
-        Commands::Scan => {
-            commands::scan::execute();
+        Commands::Scan(args) => {
+            commands::scan::execute(args);
         }
 
-        Commands::Analyze => {
-            commands::analyze::execute();
+        Commands::Analyze(args) => {
+            commands::analyze::execute(args);
         }
 
         Commands::Clean(args) => {
             if args.dry_run {
-                commands::clean::dry_run();
+                commands::clean::dry_run(&args);
             } else {
-                commands::clean::execute();
+                commands::clean::execute(&args);
             }
         }
     }

apps/dustfril-cli/src/shared/mod.rs

@@ -0,0 +1 @@
+pub mod path;

apps/dustfril-cli/src/shared/path.rs

@@ -0,0 +1,16 @@
+use std::path::{Path, PathBuf};
+
+pub fn validate_path(path: &Path) -> bool {
+    if !path.exists() {
+        eprintln!("Path does not exist: {}", path.display());
+
+        return false;
+    }
+
+    true
+}
+
+pub fn resolve_path(path: &Option<PathBuf>) -> PathBuf {
+    path.clone()
+        .unwrap_or_else(|| std::env::current_dir().expect("Failed to get current directory"))
+}

crates/dustfril-core/src/detector/mod.rs

@@ -1,10 +1,8 @@
-mod cargo_project;
-mod git;
-mod registry;
+mod project;
+mod rust;
 mod scan;
-mod target;
 
 #[cfg(test)]
 mod tests;
 
-pub use scan::{scan, scan_global, scan_project};
+pub use scan::{scan, scan_global, scan_project, scan_workspace};

crates/dustfril-core/src/detector/project.rs

@@ -0,0 +1,53 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+// pub enum Ecosystem {
+// Rust,
+// Node,
+// Java,
+// }
+
+#[derive(Debug, Clone)]
+pub struct Project {
+    pub root: PathBuf,
+    // pub ecosystem: Ecosystem,
+}
+
+pub fn find_projects(root: &Path) -> Vec<Project> {
+    let mut projects = Vec::new();
+
+    visit(root, &mut projects);
+
+    projects
+}
+
+/// Cargo project detection and artifact scanning.
+pub fn is_cargo_project(root: &Path) -> bool {
+    root.join("Cargo.toml").is_file()
+}
+
+fn visit(dir: &Path, projects: &mut Vec<Project>) {
+    if is_cargo_project(dir) {
+        projects.push(Project {
+            root: dir.to_path_buf(),
+            // ecosystem: Ecosystem::Rust,
+        });
+
+        return;
+    }
+
+    let Ok(entries) = fs::read_dir(dir) else {
+        return;
+    };
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+
+        if path.is_dir() {
+            visit(&path, projects);
+        }
+    }
+}

crates/dustfril-core/src/detector/rust/mod.rs

@@ -0,0 +1,3 @@
+pub mod git;
+pub mod registry;
+pub mod target;

crates/dustfril-core/src/detector/scan.rs

@@ -2,12 +2,16 @@ use std::path::Path;
 
 use crate::models::ScanResult;
 
-use super::{cargo_project, git, registry, target};
+use super::{
+    project,
+    rust::{git, registry, target},
+};
 
+// Scan a single Rust project for artifacts.
 pub fn scan_project(root: &Path) -> ScanResult {
     let mut result = ScanResult::default();
 
-    if !cargo_project::is_cargo_project(root) {
+    if !project::is_cargo_project(root) {
         return result;
     }
 
@@ -18,6 +22,22 @@ pub fn scan_project(root: &Path) -> ScanResult {
     result
 }
 
+// Recursively scan for Rust projects and their artifacts.
+pub fn scan_workspace(root: &Path) -> ScanResult {
+    let mut result = ScanResult::default();
+
+    let projects = project::find_projects(root);
+
+    for project in projects {
+        let project_result = scan_project(&project.root);
+
+        result.artifacts.extend(project_result.artifacts);
+    }
+
+    result
+}
+
+// Global artifacts that are not tied to a specific project, like Cargo registry and Git repositories.
 pub fn scan_global() -> ScanResult {
     let mut result = ScanResult::default();
 
@@ -33,7 +53,7 @@ pub fn scan_global() -> ScanResult {
 }
 
 pub fn scan(root: &Path) -> ScanResult {
-    let mut result = scan_project(root);
+    let mut result = scan_workspace(root);
 
     result.artifacts.extend(scan_global().artifacts);