rsconstruct 0.9.180

Rust based fast build system
use super::{Builder, sorted_keys};
use crate::color;
use anyhow::Result;
use serde::Serialize;
use std::process::Command;

#[derive(Serialize)]
struct DoctorCheck {
    name: String,
    status: &'static str,
    category: &'static str,
    #[serde(skip_serializing_if = "Option::is_none")]
    detail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    install_hint: Option<String>,
}

impl Builder {
    /// Run diagnostic checks on the build environment.
    pub fn doctor(&self, ctx: &crate::build_context::BuildContext) -> Result<()> {
        let json_mode = crate::json_output::is_json_mode();
        let mut ok_count = 0usize;
        let mut fail_count = 0usize;
        let mut warn_count = 0usize;
        let mut checks: Vec<DoctorCheck> = Vec::new();

        let mut record = |name: String,
                          status: &'static str,
                          category: &'static str,
                          detail: Option<String>,
                          install_hint: Option<String>,
                          ok: &mut usize,
                          fail: &mut usize,
                          warn: &mut usize| {
            match status {
                "ok" => *ok += 1,
                "fail" => *fail += 1,
                "warn" => *warn += 1,
                _ => {}
            }
            if !json_mode {
                let detail_str = detail
                    .as_deref()
                    .map(|d| format!(" ({d})"))
                    .unwrap_or_default();
                let hint_str = install_hint
                    .as_deref()
                    .map(|h| format!("  install: {h}"))
                    .unwrap_or_default();
                let tag: String = match status {
                    "ok" => color::green("[ok]").to_string(),
                    "fail" => color::red("[FAIL]").to_string(),
                    "warn" => color::yellow("[warn]").to_string(),
                    _ => status.to_string(),
                };
                println!("{tag} {name}{detail_str}{hint_str}");
            }
            checks.push(DoctorCheck {
                name,
                status,
                category,
                detail,
                install_hint,
            });
        };

        // Check rsconstruct.toml
        if std::path::Path::new("rsconstruct.toml").exists() {
            record(
                "rsconstruct.toml found and valid".to_string(),
                "ok",
                "config",
                None,
                None,
                &mut ok_count,
                &mut fail_count,
                &mut warn_count,
            );
        } else {
            record(
                "rsconstruct.toml not found".to_string(),
                "fail",
                "config",
                None,
                None,
                &mut ok_count,
                &mut fail_count,
                &mut warn_count,
            );
        }

        // Check .rsconstructignore
        if std::path::Path::new(".rsconstructignore").exists() {
            record(
                ".rsconstructignore found".to_string(),
                "ok",
                "config",
                None,
                None,
                &mut ok_count,
                &mut fail_count,
                &mut warn_count,
            );
        } else {
            record(
                ".rsconstructignore not found (optional)".to_string(),
                "warn",
                "config",
                None,
                None,
                &mut ok_count,
                &mut fail_count,
                &mut warn_count,
            );
        }

        // Check tools for enabled processors. A stanza with `enabled = false`
        // is kept precisely so its tool need not be installed, so its
        // absence is not a finding.
        let processors = self.create_processors()?;
        let mut checked_tools = std::collections::HashSet::new();

        for name in sorted_keys(&processors) {
            if !super::tools::instance_enabled(&processors, name) {
                continue;
            }
            let processor = &processors[name];
            for tool in processor.required_tools() {
                if !checked_tools.insert(tool.clone()) {
                    continue;
                }
                if let Some(version) = tool_version(ctx, &tool) {
                    record(
                        format!("{tool} available"),
                        "ok",
                        "tool",
                        Some(version),
                        None,
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                } else {
                    let install_hint = crate::tools::tool_install_command(&tool);
                    record(
                        format!("{tool} not found"),
                        "fail",
                        "tool",
                        None,
                        install_hint,
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                }
            }
        }

        // Check declared dependencies. The Python set is uv.lock's closure,
        // which `tool install project` puts into the repo's .venv.
        let deps = &self.config.dependencies;
        let pip_deps = crate::config::python_deps(std::path::Path::new("."))?;
        // The Node set comes from package.json; installed means present in
        // the project's node_modules (a global copy is not what the lock
        // asked for).
        let node_deps = deps.node_deps(std::path::Path::new("."))?;
        if !deps.is_empty() || !pip_deps.is_empty() || !node_deps.is_empty() {
            if !json_mode {
                println!();
                println!("{}:", color::bold("Declared dependencies"));
            }

            for pkg in &deps.system {
                // A system dependency is a package, not a tool: ask the
                // package manager whether it is installed. which() is wrong
                // here — packages like aspell-en (a dictionary) ship no
                // binary named after themselves, so which() reported them
                // as missing even right after an install put them on.
                if super::tools::is_system_package_installed(ctx, pkg) {
                    record(
                        format!("{pkg} (system)"),
                        "ok",
                        "dependency",
                        None,
                        None,
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                } else {
                    record(
                        format!("{pkg} not found"),
                        "fail",
                        "dependency",
                        Some("system".to_string()),
                        Some("rsconstruct tool install machine".to_string()),
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                }
            }

            // Python packages are judged by the interpreter, with the probe
            // `tool check` uses: `pip show` fails outright in a uv-managed
            // venv (the default installer's), which has no pip.
            let pip_names: Vec<String> = pip_deps
                .iter()
                .map(|pkg| crate::config::normalized_distribution_name(pkg))
                .collect();
            let installed_pip = if pip_names.is_empty() {
                std::collections::BTreeMap::new()
            } else {
                let names: Vec<&str> = pip_names.iter().map(String::as_str).collect();
                crate::tool_lock::installed_pip_versions(ctx, &names)
            };
            for (pkg, name) in pip_deps.iter().zip(&pip_names) {
                let found = installed_pip.contains_key(name);
                if found {
                    record(
                        format!("{pkg} (pip)"),
                        "ok",
                        "dependency",
                        None,
                        None,
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                } else {
                    record(
                        format!("{pkg} not installed"),
                        "fail",
                        "dependency",
                        Some("pip".to_string()),
                        Some("rsconstruct tool install project".to_string()),
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                }
            }

            // `[dependencies]` cargo, npm and gem entries are installed into
            // the project's tool directory, so that is where they are looked
            // for — the same place `tool check` reads — not on the machine.
            // Whether each is at its locked version is `tool check`'s job.
            let in_project = crate::tool_store::installed_versions(std::path::Path::new("."));
            for (method, list) in [
                ("cargo", &deps.cargo),
                ("gem", &deps.gem),
                ("npm", &deps.npm),
            ] {
                for pkg in list {
                    let name = crate::tool_lock::split_versioned(method, pkg)
                        .map_or_else(|| pkg.clone(), |(name, _)| name);
                    if in_project.contains_key(&(method.to_string(), name)) {
                        record(
                            format!("{pkg} ({method})"),
                            "ok",
                            "dependency",
                            None,
                            None,
                            &mut ok_count,
                            &mut fail_count,
                            &mut warn_count,
                        );
                    } else {
                        record(
                            format!(
                                "{pkg} not installed in {}",
                                crate::tool_store::REPO_TOOLS_DIR
                            ),
                            "fail",
                            "dependency",
                            Some(method.to_string()),
                            Some("rsconstruct tool install project".to_string()),
                            &mut ok_count,
                            &mut fail_count,
                            &mut warn_count,
                        );
                    }
                }
            }

            for pkg in &node_deps {
                let found =
                    crate::config::installed_node_package_version(std::path::Path::new("."), pkg)
                        .is_some();
                if found {
                    record(
                        format!("{pkg} (package.json)"),
                        "ok",
                        "dependency",
                        None,
                        None,
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                } else {
                    record(
                        format!("{pkg} not installed in node_modules"),
                        "fail",
                        "dependency",
                        Some("npm".to_string()),
                        Some("rsconstruct tool install project".to_string()),
                        &mut ok_count,
                        &mut fail_count,
                        &mut warn_count,
                    );
                }
            }
        }

        let total = ok_count + fail_count;

        if json_mode {
            let out = serde_json::json!({
                "checks": checks,
                "summary": {
                    "ok": ok_count,
                    "fail": fail_count,
                    "warn": warn_count,
                    "total": total,
                },
            });
            println!("{}", serde_json::to_string_pretty(&out)?);
        } else {
            println!();
            let summary = format!("Summary: {ok_count}/{total} checks passed");
            if fail_count == 0 {
                println!("{}", color::green(&summary));
            } else {
                println!("{}", color::yellow(&summary));
            }
        }

        Ok(())
    }
}

/// Try to get the version string of a tool by running `tool --version`.
fn tool_version(ctx: &crate::build_context::BuildContext, tool: &str) -> Option<String> {
    let mut cmd = Command::new(tool);
    cmd.arg("--version");
    let output = crate::processor::run_command_capture(ctx, &cmd).ok()?;
    if !output.status.success() {
        return None;
    }
    let version = String::from_utf8_lossy(&output.stdout);
    let version = version.trim();
    if version.is_empty() {
        let version = String::from_utf8_lossy(&output.stderr);
        let first_line = version.lines().next().unwrap_or("").trim();
        if first_line.is_empty() {
            return Some("ok".to_string());
        }
        return Some(first_line.to_string());
    }
    Some(version.lines().next().unwrap_or(version).to_string())
}