changepacks_cli/commands/

check.rs

use changepacks_core::{ChangePackResultLog, Language, Project, UpdateType};

use anyhow::Result;
use changepacks_utils::{
    apply_reverse_dependencies, display_update, gen_changepack_result_map, gen_update_map,
    get_relative_path,
};
use clap::Args;
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};

use crate::{
    CommandContext,
    options::{CliLanguage, FilterOptions, FormatOptions},
};

#[derive(Args, Debug)]
#[command(about = "Check project status")]
pub struct CheckArgs {
    #[arg(short, long)]
    filter: Option<FilterOptions>,

    #[arg(long, default_value = "stdout")]
    format: FormatOptions,

    #[arg(short, long, default_value = "false")]
    remote: bool,

    #[arg(long)]
    tree: bool,

    /// Filter projects by language. Can be specified multiple times to include multiple languages.
    #[arg(short, long, value_enum)]
    pub language: Vec<CliLanguage>,
}

/// Check project status
///
/// # Errors
/// Returns error if command context creation or project checking fails.
pub async fn handle_check(args: &CheckArgs) -> Result<()> {
    let ctx = CommandContext::new(args.remote).await?;

    let mut projects = ctx
        .project_finders
        .iter()
        .flat_map(|finder| finder.projects())
        .collect::<Vec<_>>();
    if let Some(filter) = &args.filter {
        projects.retain(|p| filter.matches(p));
    }
    if !args.language.is_empty() {
        let allowed_languages: Vec<Language> = args
            .language
            .iter()
            .map(|&lang| Language::from(lang))
            .collect();
        projects.retain(|project| allowed_languages.contains(&project.language()));
    }
    projects.sort();
    if let FormatOptions::Stdout = args.format {
        println!("Found {} projects", projects.len());
    }
    let mut update_map = gen_update_map(&CommandContext::current_dir()?, &ctx.config).await?;

    // Apply reverse dependency updates (workspace:* dependencies)
    apply_reverse_dependencies(&mut update_map, &projects, &ctx.repo_root_path);

    if args.tree {
        // Tree mode: show dependencies as a tree
        display_tree(&projects, &ctx.repo_root_path, &update_map)?;
    } else {
        match args.format {
            FormatOptions::Stdout => {
                use colored::Colorize;
                for project in projects {
                    let changed_marker = if project.is_changed() {
                        " (changed)".bright_yellow()
                    } else {
                        "".normal()
                    };
                    println!(
                        "{}",
                        format!("{project}{changed_marker}",).replace(
                            &project
                                .version()
                                .map_or_else(|| "unknown".to_string(), |v| format!("v{v}"),),
                            &if let Some(update_type) = update_map
                                .get(&get_relative_path(&ctx.repo_root_path, project.path())?)
                            {
                                display_update(project.version(), update_type.0)?
                            } else {
                                project
                                    .version()
                                    .map_or_else(|| "unknown".to_string(), |v| format!("v{v}"))
                            },
                        ),
                    );
                }
            }
            FormatOptions::Json => {
                let json = serde_json::to_string_pretty(&gen_changepack_result_map(
                    projects.as_slice(),
                    &ctx.repo_root_path,
                    &mut update_map,
                )?)?;
                println!("{json}");
            }
        }
    }
    Ok(())
}

/// Display projects as a dependency tree
fn display_tree(
    projects: &[&Project],
    repo_root_path: &std::path::Path,
    update_map: &HashMap<PathBuf, (UpdateType, Vec<ChangePackResultLog>)>,
) -> Result<()> {
    // Create a map from project relative_path to project
    let mut path_to_project: HashMap<String, &Project> = HashMap::new();
    for project in projects {
        path_to_project.insert(project.name().unwrap_or("noname").to_string(), project);
    }

    // Build reverse dependency graph: graph[dep] = list of projects that depend on dep
    // This way, dependencies appear as children in the tree
    let mut graph: HashMap<String, Vec<String>> = HashMap::new();
    let mut roots: HashSet<String> = HashSet::new();
    let mut has_dependencies: HashSet<String> = HashSet::new();

    for project in projects {
        let deps = project.dependencies();
        // Filter dependencies to only include monorepo projects
        let monorepo_deps: Vec<String> = deps
            .iter()
            .filter(|dep| path_to_project.contains_key(*dep))
            .cloned()
            .collect();

        if !monorepo_deps.is_empty() {
            graph.insert(
                project.name().unwrap_or("noname").to_string(),
                monorepo_deps.clone(),
            );
            for dep in &monorepo_deps {
                has_dependencies.insert(dep.clone());
            }
        }
    }

    // Root nodes are projects that are not dependencies of any other project
    for project in projects {
        if !has_dependencies.contains(project.name().unwrap_or("noname")) {
            roots.insert(project.name().unwrap_or("noname").to_string());
        }
    }

    // Sort roots for consistent output
    let mut sorted_roots: Vec<String> = roots.into_iter().collect();
    sorted_roots.sort();

    // Display tree starting from roots
    let mut visited: HashSet<String> = HashSet::new();
    let mut ctx = TreeContext {
        graph: &graph,
        path_to_project: &path_to_project,
        repo_root_path,
        update_map,
    };
    for (idx, root) in sorted_roots.iter().enumerate() {
        if let Some(project) = path_to_project.get(root) {
            let is_last = idx == sorted_roots.len() - 1;
            display_tree_node(project, &mut ctx, "", is_last, &mut visited)?;
        }
    }

    // Display projects that weren't part of the tree (orphaned nodes)
    for project in projects {
        if !visited.contains(project.name().unwrap_or("noname")) {
            println!(
                "{}",
                format_project_line(project, repo_root_path, update_map, &path_to_project)?
            );
        }
    }

    Ok(())
}

/// Context for tree display operations
struct TreeContext<'a> {
    graph: &'a HashMap<String, Vec<String>>,
    path_to_project: &'a HashMap<String, &'a Project>,
    repo_root_path: &'a Path,
    update_map: &'a HashMap<PathBuf, (UpdateType, Vec<ChangePackResultLog>)>,
}

/// Display a single node in the tree
fn display_tree_node(
    project: &Project,
    ctx: &mut TreeContext,
    prefix: &str,
    is_last: bool,
    visited: &mut HashSet<String>,
) -> Result<()> {
    let project_name = project.name().unwrap_or("noname").to_string();
    let is_first_visit = !visited.contains(&project_name);
    if is_first_visit {
        visited.insert(project_name.clone());
    }

    // Only print the project line if this is the first time visiting it
    if is_first_visit {
        let connector = if is_last { "└── " } else { "├── " };
        println!(
            "{}{}{}",
            prefix,
            connector,
            format_project_line(
                project,
                ctx.repo_root_path,
                ctx.update_map,
                ctx.path_to_project
            )?
        );
    }

    // Always display dependencies, even if the node was already visited
    // This ensures all dependencies are shown in the tree
    if let Some(deps) = ctx.graph.get(&project_name) {
        let mut sorted_deps = deps.clone();
        sorted_deps.sort();
        let sorted_deps_count = sorted_deps.len();
        for (idx, dep_name) in sorted_deps.iter().enumerate() {
            if let Some(dep_project) = ctx.path_to_project.get(dep_name) {
                let is_last_dep = idx == sorted_deps_count - 1;
                let new_prefix = format!("{}{}", prefix, if is_last { "    " } else { "│   " });
                // Use a separate visited set for dependencies to avoid infinite loops
                // but still show all dependencies
                if visited.contains(dep_name) {
                    // If already visited, just print it without recursion to avoid loops
                    let dep_connector = if is_last_dep {
                        "└── "
                    } else {
                        "├── "
                    };
                    println!(
                        "{}{}{}",
                        new_prefix,
                        dep_connector,
                        format_project_line(
                            dep_project,
                            ctx.repo_root_path,
                            ctx.update_map,
                            ctx.path_to_project
                        )?
                    );
                } else {
                    display_tree_node(dep_project, ctx, &new_prefix, is_last_dep, visited)?;
                }
            }
        }
    }

    Ok(())
}

/// Format a project line for display
fn format_project_line(
    project: &Project,
    repo_root_path: &std::path::Path,
    update_map: &HashMap<PathBuf, (UpdateType, Vec<ChangePackResultLog>)>,
    path_to_project: &HashMap<String, &Project>,
) -> Result<String> {
    use changepacks_utils::get_relative_path;
    use colored::Colorize;

    let relative_path = get_relative_path(repo_root_path, project.path())?;
    let version = if let Some(update_entry) = update_map.get(&relative_path) {
        changepacks_utils::display_update(project.version(), update_entry.0)?
    } else {
        project
            .version()
            .map_or_else(|| "unknown".to_string(), |v| format!("v{v}"))
    };

    let changed_marker = if project.is_changed() {
        " (changed)".bright_yellow()
    } else {
        "".normal()
    };

    // Only show dependencies that are in the monorepo (in path_to_project)
    let monorepo_deps: Vec<&String> = project
        .dependencies()
        .iter()
        .filter(|dep| path_to_project.contains_key(*dep))
        .collect();

    let deps_info = if monorepo_deps.is_empty() {
        "".normal()
    } else {
        let deps_str = monorepo_deps
            .iter()
            .map(|d| d.as_str())
            .collect::<Vec<_>>()
            .join("\n        ");
        format!(" [deps:\n        {deps_str}]").bright_black()
    };

    // Format similar to Project::Display but with version update and dependencies
    let base_format = match project {
        Project::Workspace(w) => format!(
            "{} {} {} {} {}",
            format!("[Workspace - {}]", w.language())
                .bright_blue()
                .bold(),
            w.name().unwrap_or("noname").bright_white().bold(),
            format!("({version})").bright_green(),
            "-".bright_cyan(),
            w.relative_path().display().to_string().bright_black()
        ),
        Project::Package(p) => format!(
            "{} {} {} {} {}",
            format!("[{}]", p.language()).bright_blue().bold(),
            p.name().unwrap_or("noname").bright_white().bold(),
            format!("({version})").bright_green(),
            "-".bright_cyan(),
            p.relative_path().display().to_string().bright_black()
        ),
    };

    Ok(format!("{base_format}{changed_marker}{deps_info}"))
}

#[cfg(test)]
mod tests {
    use super::*;
    use clap::Parser;

    // Test CheckArgs parsing via clap
    #[derive(Parser)]
    struct TestCli {
        #[command(flatten)]
        check: CheckArgs,
    }

    #[test]
    fn test_check_args_default() {
        let cli = TestCli::parse_from(["test"]);
        assert!(cli.check.filter.is_none());
        assert!(matches!(cli.check.format, FormatOptions::Stdout));
        assert!(!cli.check.remote);
        assert!(!cli.check.tree);
    }

    #[test]
    fn test_check_args_with_json_format() {
        let cli = TestCli::parse_from(["test", "--format", "json"]);
        assert!(matches!(cli.check.format, FormatOptions::Json));
    }

    #[test]
    fn test_check_args_with_tree() {
        let cli = TestCli::parse_from(["test", "--tree"]);
        assert!(cli.check.tree);
    }

    #[test]
    fn test_check_args_with_remote() {
        let cli = TestCli::parse_from(["test", "--remote"]);
        assert!(cli.check.remote);
    }

    #[test]
    fn test_check_args_with_filter_workspace() {
        let cli = TestCli::parse_from(["test", "--filter", "workspace"]);
        assert!(matches!(cli.check.filter, Some(FilterOptions::Workspace)));
    }

    #[test]
    fn test_check_args_with_filter_package() {
        let cli = TestCli::parse_from(["test", "--filter", "package"]);
        assert!(matches!(cli.check.filter, Some(FilterOptions::Package)));
    }

    #[test]
    fn test_check_args_combined() {
        let cli = TestCli::parse_from([
            "test", "--filter", "package", "--format", "json", "--tree", "--remote",
        ]);
        assert!(matches!(cli.check.filter, Some(FilterOptions::Package)));
        assert!(matches!(cli.check.format, FormatOptions::Json));
        assert!(cli.check.tree);
        assert!(cli.check.remote);
    }

    #[test]
    fn test_check_args_short_filter() {
        let cli = TestCli::parse_from(["test", "-f", "workspace"]);
        assert!(matches!(cli.check.filter, Some(FilterOptions::Workspace)));
    }

    #[test]
    fn test_check_args_short_remote() {
        let cli = TestCli::parse_from(["test", "-r"]);
        assert!(cli.check.remote);
    }

    #[test]
    fn test_check_args_with_language_filter() {
        let cli = TestCli::parse_from(["test", "--language", "node"]);
        assert_eq!(cli.check.language.len(), 1);
    }

    #[test]
    fn test_check_args_with_multiple_languages() {
        let cli = TestCli::parse_from(["test", "--language", "node", "--language", "python"]);
        assert_eq!(cli.check.language.len(), 2);
    }

    #[test]
    fn test_check_args_short_language() {
        let cli = TestCli::parse_from(["test", "-l", "rust"]);
        assert_eq!(cli.check.language.len(), 1);
    }

    // --- format_project_line tests using mock trait implementations ---

    use async_trait::async_trait;
    use changepacks_core::{Language, Package, Workspace};
    use std::collections::HashSet;

    #[derive(Debug)]
    struct MockPackageForCheck {
        name: Option<String>,
        version: Option<String>,
        path: PathBuf,
        relative_path: PathBuf,
        language: Language,
        dependencies: HashSet<String>,
        changed: bool,
    }

    impl MockPackageForCheck {
        fn new(
            name: Option<&str>,
            version: Option<&str>,
            path: &str,
            relative_path: &str,
            language: Language,
        ) -> Self {
            Self {
                name: name.map(String::from),
                version: version.map(String::from),
                path: PathBuf::from(path),
                relative_path: PathBuf::from(relative_path),
                language,
                dependencies: HashSet::new(),
                changed: false,
            }
        }
    }

    #[async_trait]
    impl Package for MockPackageForCheck {
        fn name(&self) -> Option<&str> {
            self.name.as_deref()
        }
        fn version(&self) -> Option<&str> {
            self.version.as_deref()
        }
        fn path(&self) -> &std::path::Path {
            &self.path
        }
        fn relative_path(&self) -> &std::path::Path {
            &self.relative_path
        }
        async fn update_version(
            &mut self,
            _update_type: changepacks_core::UpdateType,
        ) -> anyhow::Result<()> {
            Ok(())
        }
        fn is_changed(&self) -> bool {
            self.changed
        }
        fn language(&self) -> Language {
            self.language
        }
        fn dependencies(&self) -> &HashSet<String> {
            &self.dependencies
        }
        fn add_dependency(&mut self, dependency: &str) {
            self.dependencies.insert(dependency.to_string());
        }
        fn set_changed(&mut self, changed: bool) {
            self.changed = changed;
        }
        fn default_publish_command(&self) -> String {
            "echo publish".to_string()
        }
    }

    #[derive(Debug)]
    struct MockWorkspaceForCheck {
        name: Option<String>,
        version: Option<String>,
        path: PathBuf,
        relative_path: PathBuf,
        language: Language,
        dependencies: HashSet<String>,
        changed: bool,
    }

    impl MockWorkspaceForCheck {
        fn new(
            name: Option<&str>,
            version: Option<&str>,
            path: &str,
            relative_path: &str,
            language: Language,
        ) -> Self {
            Self {
                name: name.map(String::from),
                version: version.map(String::from),
                path: PathBuf::from(path),
                relative_path: PathBuf::from(relative_path),
                language,
                dependencies: HashSet::new(),
                changed: false,
            }
        }
    }

    #[async_trait]
    impl Workspace for MockWorkspaceForCheck {
        fn name(&self) -> Option<&str> {
            self.name.as_deref()
        }
        fn version(&self) -> Option<&str> {
            self.version.as_deref()
        }
        fn path(&self) -> &std::path::Path {
            &self.path
        }
        fn relative_path(&self) -> &std::path::Path {
            &self.relative_path
        }
        async fn update_version(
            &mut self,
            _update_type: changepacks_core::UpdateType,
        ) -> anyhow::Result<()> {
            Ok(())
        }
        fn is_changed(&self) -> bool {
            self.changed
        }
        fn language(&self) -> Language {
            self.language
        }
        fn dependencies(&self) -> &HashSet<String> {
            &self.dependencies
        }
        fn add_dependency(&mut self, dependency: &str) {
            self.dependencies.insert(dependency.to_string());
        }
        fn set_changed(&mut self, changed: bool) {
            self.changed = changed;
        }
        fn default_publish_command(&self) -> String {
            "echo publish".to_string()
        }
    }

    #[test]
    fn test_format_project_line_package() {
        let pkg = MockPackageForCheck::new(
            Some("my-lib"),
            Some("1.2.3"),
            "/repo/crates/my-lib/Cargo.toml",
            "crates/my-lib/Cargo.toml",
            Language::Rust,
        );
        let project = Project::Package(Box::new(pkg));
        let repo_root = Path::new("/repo");
        let update_map = HashMap::new();
        let mut path_to_project: HashMap<String, &Project> = HashMap::new();
        path_to_project.insert("my-lib".to_string(), &project);

        let line = format_project_line(&project, repo_root, &update_map, &path_to_project).unwrap();
        assert!(line.contains("my-lib"));
        assert!(line.contains("v1.2.3"));
    }

    #[test]
    fn test_format_project_line_workspace() {
        let ws = MockWorkspaceForCheck::new(
            Some("my-workspace"),
            Some("2.0.0"),
            "/repo/package.json",
            "package.json",
            Language::Node,
        );
        let project = Project::Workspace(Box::new(ws));
        let repo_root = Path::new("/repo");
        let update_map = HashMap::new();
        let mut path_to_project: HashMap<String, &Project> = HashMap::new();
        path_to_project.insert("my-workspace".to_string(), &project);

        let line = format_project_line(&project, repo_root, &update_map, &path_to_project).unwrap();
        assert!(line.contains("my-workspace"));
        assert!(line.contains("Workspace"));
        assert!(line.contains("v2.0.0"));
    }

    #[test]
    fn test_format_project_line_with_update() {
        let pkg = MockPackageForCheck::new(
            Some("updated-pkg"),
            Some("1.0.0"),
            "/repo/packages/foo/package.json",
            "packages/foo/package.json",
            Language::Node,
        );
        let project = Project::Package(Box::new(pkg));
        let repo_root = Path::new("/repo");
        let mut update_map = HashMap::new();
        update_map.insert(
            PathBuf::from("packages/foo/package.json"),
            (UpdateType::Minor, vec![]),
        );
        let path_to_project: HashMap<String, &Project> = HashMap::new();

        let line = format_project_line(&project, repo_root, &update_map, &path_to_project).unwrap();
        assert!(line.contains("updated-pkg"));
        // The update display should show version transition
        assert!(line.contains("1.1.0") || line.contains("1.0.0"));
    }

    #[test]
    fn test_format_project_line_changed_marker() {
        let mut pkg = MockPackageForCheck::new(
            Some("changed-pkg"),
            Some("3.0.0"),
            "/repo/lib/Cargo.toml",
            "lib/Cargo.toml",
            Language::Rust,
        );
        pkg.changed = true;
        let project = Project::Package(Box::new(pkg));
        let repo_root = Path::new("/repo");
        let update_map = HashMap::new();
        let path_to_project: HashMap<String, &Project> = HashMap::new();

        let line = format_project_line(&project, repo_root, &update_map, &path_to_project).unwrap();
        assert!(line.contains("changed-pkg"));
        assert!(line.contains("changed"));
    }

    #[test]
    fn test_format_project_line_with_dependencies() {
        let mut pkg = MockPackageForCheck::new(
            Some("app"),
            Some("1.0.0"),
            "/repo/app/package.json",
            "app/package.json",
            Language::Node,
        );
        pkg.dependencies.insert("core-lib".to_string());
        let project = Project::Package(Box::new(pkg));

        let dep_pkg = MockPackageForCheck::new(
            Some("core-lib"),
            Some("1.0.0"),
            "/repo/core/package.json",
            "core/package.json",
            Language::Node,
        );
        let dep_project = Project::Package(Box::new(dep_pkg));

        let repo_root = Path::new("/repo");
        let update_map = HashMap::new();
        let mut path_to_project: HashMap<String, &Project> = HashMap::new();
        path_to_project.insert("app".to_string(), &project);
        path_to_project.insert("core-lib".to_string(), &dep_project);

        let line = format_project_line(&project, repo_root, &update_map, &path_to_project).unwrap();
        assert!(line.contains("app"));
        assert!(line.contains("deps:"));
        assert!(line.contains("core-lib"));
    }

    #[test]
    fn test_format_project_line_no_deps_shows_no_bracket() {
        let pkg = MockPackageForCheck::new(
            Some("standalone"),
            Some("1.0.0"),
            "/repo/standalone/Cargo.toml",
            "standalone/Cargo.toml",
            Language::Rust,
        );
        let project = Project::Package(Box::new(pkg));
        let repo_root = Path::new("/repo");
        let update_map = HashMap::new();
        let path_to_project: HashMap<String, &Project> = HashMap::new();

        let line = format_project_line(&project, repo_root, &update_map, &path_to_project).unwrap();
        assert!(line.contains("standalone"));
        assert!(!line.contains("deps:"));
    }
}