bridge 0.1.3

Command Line Interface for BridgeRust framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use anyhow::Result;
use console::style;
use std::fs;
use std::path::PathBuf;

/// Find the project root by looking for Cargo.toml or bridgerust.toml
fn find_project_root() -> Result<PathBuf> {
    let mut current = std::env::current_dir()?;

    loop {
        let cargo_toml = current.join("Cargo.toml");
        let bridgerust_toml = current.join("bridgerust.toml");

        if cargo_toml.exists() || bridgerust_toml.exists() {
            return Ok(current);
        }

        match current.parent() {
            Some(parent) => current = parent.to_path_buf(),
            None => anyhow::bail!("Could not find project root (Cargo.toml or bridgerust.toml)"),
        }
    }
}

/// Get the cache directory for BridgeRust builds
fn get_cache_dir() -> Result<PathBuf> {
    let cache_dir = dirs::cache_dir()
        .ok_or_else(|| anyhow::anyhow!("Could not find cache directory"))?
        .join("bridgerust");
    Ok(cache_dir)
}

pub async fn handle(target: Option<String>, cache: bool) -> Result<()> {
    println!(
        "{}",
        style("🧹 Cleaning BridgeRust project...").bold().cyan()
    );

    let project_root = find_project_root()?;
    println!("  Project root: {}", project_root.display());

    let targets: Vec<&str> = match target.as_deref() {
        Some("all") | None => vec!["python", "nodejs", "rust"],
        Some("python") => vec!["python"],
        Some("nodejs") => vec!["nodejs"],
        Some("rust") => vec!["rust"],
        Some(other) => anyhow::bail!(
            "Invalid target: {}. Use 'python', 'nodejs', 'rust', or 'all'",
            other
        ),
    };

    let mut cleaned = Vec::new();

    for target in &targets {
        match *target {
            "python" => {
                let python_dir = project_root.join("python");
                let wheels_dir = python_dir.join("target").join("wheels");
                let dist_dir = python_dir.join("dist");

                if wheels_dir.exists() {
                    fs::remove_dir_all(&wheels_dir)?;
                    cleaned.push(format!("Python wheels ({})", wheels_dir.display()));
                }

                if dist_dir.exists() {
                    fs::remove_dir_all(&dist_dir)?;
                    cleaned.push(format!("Python dist ({})", dist_dir.display()));
                }

                // Clean maturin build artifacts
                let maturin_target = python_dir.join("target");
                if maturin_target.exists() && maturin_target.join("wheels").exists() {
                    let wheels = maturin_target.join("wheels");
                    if wheels.exists() {
                        fs::remove_dir_all(&wheels)?;
                        cleaned.push(format!("Maturin wheels ({})", wheels.display()));
                    }
                }
            }
            "nodejs" => {
                let nodejs_dir = project_root.join("nodejs");
                let index_node = nodejs_dir.join("index.node");
                let index_js = nodejs_dir.join("index.js");
                let index_d_ts = nodejs_dir.join("index.d.ts");

                if index_node.exists() {
                    fs::remove_file(&index_node)?;
                    cleaned.push("Node.js index.node".to_string());
                }

                if index_js.exists() {
                    fs::remove_file(&index_js)?;
                    cleaned.push("Node.js index.js".to_string());
                }

                if index_d_ts.exists() {
                    fs::remove_file(&index_d_ts)?;
                    cleaned.push("Node.js index.d.ts".to_string());
                }

                // Clean napi build artifacts
                let napi_dir = nodejs_dir.join("napi");
                if napi_dir.exists() {
                    fs::remove_dir_all(&napi_dir)?;
                    cleaned.push(format!("Napi build artifacts ({})", napi_dir.display()));
                }
            }
            "rust" => {
                // Clean cargo target directory (but keep it if it has other projects)
                let target_dir = project_root.join("target");
                if target_dir.exists() {
                    // Only clean if it's a BridgeRust-specific target
                    // For now, we'll clean the whole target directory
                    // Users can use `cargo clean` for more control
                    println!(
                        "  {} Note: Use 'cargo clean' to clean Rust build artifacts",
                        style("ℹ").yellow()
                    );
                }
            }
            _ => {}
        }
    }

    // Clean cache if requested
    if cache {
        let cache_dir = get_cache_dir()?;
        if cache_dir.exists() {
            fs::remove_dir_all(&cache_dir)?;
            cleaned.push(format!("Build cache ({})", cache_dir.display()));
        }
    }

    if cleaned.is_empty() {
        println!("  {} Nothing to clean", style("ℹ").yellow());
    } else {
        println!("\n  {} Cleaned:", style("✓").green());
        for item in &cleaned {
            println!("    - {}", item);
        }
    }

    println!("\n{}", style("✅ Clean completed!").bold().green());
    Ok(())
}