Added:

- Workspace support (`[workspace]` with deps ordering)
- `clean --all` for workspace members
Changed:
- Project root discovery for `build/run/clean` (searches parent dirs)
- Workspace paths are excluded from root source scan
- Build output now uses a Cargo-style `Compiling <name> v<version>` line
- Build time now reports total time for the whole build stage (workspace included)
- Cache hits are silent (no compile line when nothing is rebuilt)
- Safer build cache: fingerprints include headers and resolved library files

src/cli/build.rs

@@ -1,117 +1,41 @@
 use crate::config::{PROFILE, flags};
-use crate::core::builder::{BuildContext, build as build_project};
+use crate::core::builder::{BuildContext, build as build_project, collect_sources};
 use crate::core::config::Config;
 use crate::core::deps::resolve_deps;
-use crate::utils::fs::check_dir;
+use crate::core::workspace::parse_workspace;
+use crate::utils::fs::{check_dir, find_project_root};
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_GREEN, colored};
+use sha2::{Digest, Sha256};
 use std::fs;
+use std::path::Path;
 use std::time::Instant;
 
 pub fn build(args: &[String]) -> i32 {
-    let items = check_dir(None).unwrap_or_default();
-    if !items.contains(&"dcr.toml".to_string()) {
-        error("dcr.toml file not found");
-        return 1;
-    }
-
-    let config = match Config::open("./dcr.toml") {
-        Ok(cfg) => cfg,
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
         Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
             error("dcr.toml file not found");
             return 1;
         }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
     };
     let active_profile = match parse_profile(args) {
         Ok(profile) => profile,
         Err(code) => return code,
     };
-    let project_name = get_config_str(&config, "package.name");
-    let project_compiler = get_config_str(&config, "build.compiler");
-    let build_language = get_config_str(&config, "build.language");
-    let build_standard = get_config_str(&config, "build.standard");
-    let build_target = get_config_str(&config, "build.target");
-    let build_kind = get_config_str(&config, "build.kind");
-    let build_platform = get_config_str(&config, "build.platform");
-    let tc_cc = get_config_opt(&config, "toolchain.cc");
-    let tc_cxx = get_config_opt(&config, "toolchain.cxx");
-    let tc_as = get_config_opt(&config, "toolchain.as");
-    let tc_ar = get_config_opt(&config, "toolchain.ar");
-    let tc_ld = get_config_opt(&config, "toolchain.ld");
-    let build_cflags = match get_config_list(&config, "build.cflags") {
-        Ok(v) => v,
-        Err(msg) => {
-            error(&msg);
-            return 1;
-        }
-    };
-    let build_ldflags = match get_config_list(&config, "build.ldflags") {
-        Ok(v) => v,
-        Err(msg) => {
-            error(&msg);
-            return 1;
-        }
-    };
-
-    let resolved_compiler = resolve_compiler(
-        &build_language,
-        &project_compiler,
-        tc_cc.as_deref(),
-        tc_cxx.as_deref(),
-        tc_as.as_deref(),
-    );
-    let resolved_linker = resolve_tool("DCR_LD", tc_ld.as_deref());
-    let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref());
-
-    println!(
-        "    Building project `{}`\n    Profile: {}\n    Compiler: {}\n",
-        colored(&project_name, BOLD_GREEN),
-        colored(&active_profile, BOLD_GREEN),
-        colored(&resolved_compiler, BOLD_GREEN)
-    );
-
-    ensure_target_dirs(&items, &active_profile, normalize_target(&build_target));
-
-    let project_root = match std::env::current_dir() {
-        Ok(p) => p,
-        Err(_) => {
-            error("Failed to determine project root");
-            return 1;
-        }
-    };
-    let resolved = match resolve_deps(&config, &active_profile, &project_root) {
-        Ok(r) => r,
-        Err(msg) => {
-            error(&msg);
-            return 1;
-        }
-    };
-    let ctx = BuildContext {
-        profile: &active_profile,
-        project_name: &project_name,
-        compiler: &resolved_compiler,
-        language: &build_language,
-        standard: &build_standard,
-        target_dir: normalize_target(&build_target),
-        kind: normalize_kind(&build_kind),
-        platform: normalize_platform(&build_platform),
-        linker: resolved_linker.as_deref(),
-        archiver: resolved_archiver.as_deref(),
-        include_dirs: &resolved.include_dirs,
-        lib_dirs: &resolved.lib_dirs,
-        libs: &resolved.libs,
-        cflags: &build_cflags,
-        ldflags: &build_ldflags,
-    };
-    match run_build(&ctx) {
-        Ok(times) => {
-            println!(
-                "    {} Build completed successfully in {} seconds",
-                colored("✔", BOLD_GREEN),
-                colored(&times.to_string(), BOLD_GREEN)
-            );
-            0
-        }
+    match with_dir(&root, || build_from_root(&root, &active_profile)) {
+        Ok(()) => 0,
         Err(msg) => {
             error(&msg);
             1
@@ -200,6 +124,136 @@ fn run_build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
+fn build_from_root(root: &Path, profile: &str) -> Result<(), String> {
+    let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+    let project_name = get_config_str(&config, "package.name");
+    let start_time = Instant::now();
+    println!(
+        "    Building project `{}`\n    Profile: {}",
+        colored(&project_name, BOLD_GREEN),
+        colored(profile, BOLD_GREEN)
+    );
+    if let Some(workspace) = parse_workspace(&config, root)? {
+        build_workspace(&workspace, profile)?;
+        let excludes: Vec<std::path::PathBuf> =
+            workspace.members.iter().map(|m| m.path.clone()).collect();
+        build_project_at(root, profile, &excludes)?;
+        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+        println!(
+            "    {} Build completed successfully in {} seconds",
+            colored("✔", BOLD_GREEN),
+            colored(&elapsed.to_string(), BOLD_GREEN)
+        );
+        return Ok(());
+    }
+    build_project_at(root, profile, &[])?;
+    let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+    println!(
+        "    {} Build completed successfully in {} seconds",
+        colored("✔", BOLD_GREEN),
+        colored(&elapsed.to_string(), BOLD_GREEN)
+    );
+    Ok(())
+}
+
+fn build_workspace(
+    workspace: &crate::core::workspace::Workspace,
+    profile: &str,
+) -> Result<(), String> {
+    for member in &workspace.members {
+        build_project_at(&member.path, profile, &[])?;
+    }
+    Ok(())
+}
+
+fn build_project_at(
+    project_root: &Path,
+    profile: &str,
+    exclude_dirs: &[std::path::PathBuf],
+) -> Result<(), String> {
+    with_dir(project_root, || {
+        let items = check_dir(None).map_err(|_| "Failed to read project directory".to_string())?;
+        if !items.contains(&"dcr.toml".to_string()) {
+            return Err("dcr.toml file not found".to_string());
+        }
+        let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+        let project_name = get_config_str(&config, "package.name");
+        let project_version = get_config_str(&config, "package.version");
+        let project_compiler = get_config_str(&config, "build.compiler");
+        let build_language = get_config_str(&config, "build.language");
+        let build_standard = get_config_str(&config, "build.standard");
+        let build_target = get_config_str(&config, "build.target");
+        let build_kind = get_config_str(&config, "build.kind");
+        let build_platform = get_config_str(&config, "build.platform");
+        let tc_cc = get_config_opt(&config, "toolchain.cc");
+        let tc_cxx = get_config_opt(&config, "toolchain.cxx");
+        let tc_as = get_config_opt(&config, "toolchain.as");
+        let tc_ar = get_config_opt(&config, "toolchain.ar");
+        let tc_ld = get_config_opt(&config, "toolchain.ld");
+        let build_cflags = get_config_list(&config, "build.cflags")?;
+        let build_ldflags = get_config_list(&config, "build.ldflags")?;
+
+        let resolved_compiler = resolve_compiler(
+            &build_language,
+            &project_compiler,
+            tc_cc.as_deref(),
+            tc_cxx.as_deref(),
+            tc_as.as_deref(),
+        );
+        let resolved_linker = resolve_tool("DCR_LD", tc_ld.as_deref());
+        let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref());
+
+        ensure_target_dirs(&items, profile, normalize_target(&build_target));
+
+        let resolved = resolve_deps(&config, profile, project_root)?;
+        let ctx = BuildContext {
+            profile,
+            project_name: &project_name,
+            compiler: &resolved_compiler,
+            language: &build_language,
+            standard: &build_standard,
+            target_dir: normalize_target(&build_target),
+            kind: normalize_kind(&build_kind),
+            platform: normalize_platform(&build_platform),
+            linker: resolved_linker.as_deref(),
+            archiver: resolved_archiver.as_deref(),
+            exclude_dirs,
+            include_dirs: &resolved.include_dirs,
+            lib_dirs: &resolved.lib_dirs,
+            libs: &resolved.libs,
+            cflags: &build_cflags,
+            ldflags: &build_ldflags,
+        };
+        let sources = collect_sources(&ctx)?;
+        let headers = collect_header_files(&ctx, project_root)?;
+        let lib_files = collect_lib_files(&ctx);
+        let fingerprint = compute_build_fingerprint(&ctx, &sources, &headers, &lib_files)?;
+        if should_skip_build(&ctx, &fingerprint) {
+            return Ok(());
+        }
+        println!(
+            "   {} {} v{}",
+            colored("Compiling", BOLD_GREEN),
+            project_name,
+            project_version
+        );
+        run_build(&ctx)?;
+        write_build_fingerprint(&ctx, &fingerprint)?;
+        Ok(())
+    })
+}
+
+fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
+where
+    F: FnOnce() -> Result<T, String>,
+{
+    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
+    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
+    let result = f();
+    let _ = std::env::set_current_dir(prev);
+    result
+}
+
 fn normalize_target(target: &str) -> Option<&str> {
     let trimmed = target.trim();
     if trimmed.is_empty() {
@@ -295,3 +349,210 @@ fn resolve_tool(env_key: &str, fallback: Option<&str>) -> Option<String> {
     }
     fallback.map(|v| v.to_string())
 }
+
+fn compute_build_fingerprint(
+    ctx: &BuildContext,
+    sources: &[String],
+    headers: &[std::path::PathBuf],
+    lib_files: &[std::path::PathBuf],
+) -> Result<String, String> {
+    let mut hasher = Sha256::new();
+    hasher.update(ctx.profile.as_bytes());
+    hasher.update(ctx.project_name.as_bytes());
+    hasher.update(ctx.compiler.as_bytes());
+    hasher.update(ctx.language.as_bytes());
+    hasher.update(ctx.standard.as_bytes());
+    hasher.update(ctx.kind.as_bytes());
+    if let Some(v) = ctx.target_dir {
+        hasher.update(v.as_bytes());
+    }
+    if let Some(v) = ctx.platform {
+        hasher.update(v.as_bytes());
+    }
+    if let Some(v) = ctx.linker {
+        hasher.update(v.as_bytes());
+    }
+    if let Some(v) = ctx.archiver {
+        hasher.update(v.as_bytes());
+    }
+    for value in ctx.include_dirs {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.lib_dirs {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.libs {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.cflags {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.ldflags {
+        hasher.update(value.as_bytes());
+    }
+    let toml =
+        fs::read_to_string("dcr.toml").map_err(|err| format!("Failed to read dcr.toml: {err}"))?;
+    hasher.update(toml.as_bytes());
+    if let Ok(lock) = fs::read_to_string("dcr.lock") {
+        hasher.update(lock.as_bytes());
+    }
+    for source in sources {
+        let path = Path::new(source);
+        update_hasher_with_file(&mut hasher, path)?;
+    }
+    for header in headers {
+        update_hasher_with_file(&mut hasher, header)?;
+    }
+    for lib in lib_files {
+        update_hasher_with_file(&mut hasher, lib)?;
+    }
+    Ok(to_hex(&hasher.finalize()))
+}
+
+fn should_skip_build(ctx: &BuildContext, fingerprint: &str) -> bool {
+    let output = build_output_path(ctx);
+    if !Path::new(&output).is_file() {
+        return false;
+    }
+    let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
+    let cached = fs::read_to_string(cache_path).unwrap_or_default();
+    cached.trim() == fingerprint
+}
+
+fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) -> Result<(), String> {
+    let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
+    if let Some(parent) = cache_path.parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("Failed to create cache dir: {err}"))?;
+    }
+    fs::write(cache_path, format!("{fingerprint}\n"))
+        .map_err(|err| format!("Failed to write cache: {err}"))
+}
+
+fn build_cache_path(profile: &str, target_dir: Option<&str>) -> std::path::PathBuf {
+    match target_dir {
+        Some(dir) => Path::new(dir).join(format!(".dcr-build.{profile}.hash")),
+        None => Path::new("./target").join(profile).join(".dcr-build.hash"),
+    }
+}
+
+fn build_output_path(ctx: &BuildContext) -> String {
+    if ctx.kind == "staticlib" {
+        return crate::platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+    }
+    if ctx.kind == "sharedlib" {
+        return crate::platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+    }
+    crate::platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+}
+
+fn collect_header_files(
+    ctx: &BuildContext,
+    project_root: &Path,
+) -> Result<Vec<std::path::PathBuf>, String> {
+    let mut out = Vec::new();
+    let mut roots = Vec::new();
+    roots.push(project_root.join("src"));
+    for dir in ctx.include_dirs {
+        roots.push(Path::new(dir).to_path_buf());
+    }
+    for root in roots {
+        if !root.exists() {
+            continue;
+        }
+        collect_header_files_rec(&root, &mut out, ctx.exclude_dirs)?;
+    }
+    out.sort();
+    out.dedup();
+    Ok(out)
+}
+
+fn collect_header_files_rec(
+    dir: &Path,
+    out: &mut Vec<std::path::PathBuf>,
+    exclude_dirs: &[std::path::PathBuf],
+) -> Result<(), String> {
+    if is_excluded(dir, exclude_dirs) {
+        return Ok(());
+    }
+    for entry in fs::read_dir(dir).map_err(|err| format!("read_dir error: {err}"))? {
+        let entry = entry.map_err(|err| format!("read_dir error: {err}"))?;
+        let path = entry.path();
+        if path.is_dir() {
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_header_files_rec(&path, out, exclude_dirs)?;
+            continue;
+        }
+        if !path.is_file() {
+            continue;
+        }
+        if is_header_file(&path) {
+            out.push(path);
+        }
+    }
+    Ok(())
+}
+
+fn is_header_file(path: &Path) -> bool {
+    let ext = path.extension().and_then(|v| v.to_str()).unwrap_or("");
+    matches!(ext, "h" | "hpp" | "hh" | "hxx" | "inc")
+}
+
+fn collect_lib_files(ctx: &BuildContext) -> Vec<std::path::PathBuf> {
+    let mut out = Vec::new();
+    for dir in ctx.lib_dirs {
+        let dir_path = Path::new(dir);
+        for lib in ctx.libs {
+            for candidate in lib_candidates(lib) {
+                let path = dir_path.join(candidate);
+                if path.is_file() {
+                    out.push(path);
+                }
+            }
+        }
+    }
+    out
+}
+
+fn lib_candidates(name: &str) -> Vec<String> {
+    if cfg!(target_os = "windows") {
+        return vec![format!("{name}.lib")];
+    }
+    if cfg!(target_os = "macos") {
+        return vec![
+            format!("lib{name}.a"),
+            format!("lib{name}.dylib"),
+            format!("lib{name}.so"),
+        ];
+    }
+    vec![
+        format!("lib{name}.a"),
+        format!("lib{name}.so"),
+        format!("lib{name}.so.0"),
+    ]
+}
+
+fn update_hasher_with_file(hasher: &mut Sha256, path: &Path) -> Result<(), String> {
+    hasher.update(path.to_string_lossy().as_bytes());
+    let meta = fs::metadata(path).map_err(|err| format!("source read error: {err}"))?;
+    hasher.update(meta.len().to_le_bytes());
+    if let Ok(modified) = meta.modified()
+        && let Ok(duration) = modified.duration_since(std::time::UNIX_EPOCH)
+    {
+        hasher.update(duration.as_nanos().to_le_bytes());
+    }
+    Ok(())
+}
+
+fn is_excluded(path: &Path, exclude_dirs: &[std::path::PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn to_hex(bytes: &[u8]) -> String {
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        out.push_str(&format!("{:02x}", b));
+    }
+    out
+}