lib.rs

mod error;
pub mod package;
mod package_manager;

use std::{collections::hash_map::Entry, fs, io, sync::Arc};

use petgraph::graph::{DefaultIx, DiGraph, EdgeIndex, IndexType, NodeIndex};
use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
use serde::Deserialize;
use vec1::smallvec_v1::SmallVec1;
use vite_glob::GlobPatternSet;
use vite_path::{AbsolutePath, AbsolutePathBuf, RelativePathBuf};
use vite_str::Str;
use wax::Glob;

pub use crate::{
    error::Error,
    package::{DependencyType, PackageJson},
    package_manager::{WorkspaceFile, WorkspaceRoot, find_package_root, find_workspace_root},
};

/// The workspace configuration for pnpm.
#[derive(Debug, Deserialize)]
struct PnpmWorkspace {
    /// The packages to include in the workspace.
    ///
    /// <https://pnpm.io/pnpm-workspace_yaml>
    #[serde(default)]
    packages: Vec<Str>,
}

/// The workspace configuration for npm/yarn.
///
/// npm: <https://docs.npmjs.com/cli/v11/using-npm/workspaces>
/// yarn: <https://yarnpkg.com/features/workspaces>
#[derive(Debug, Deserialize)]
struct NpmWorkspace {
    /// Array of folder glob patterns referencing the workspaces of the project.
    ///
    /// <https://docs.npmjs.com/cli/v11/configuring-npm/package-json#workspaces>
    /// <https://yarnpkg.com/configuration/manifest#workspaces>
    workspaces: Vec<Str>,
}

#[derive(Debug)]
struct WorkspaceMemberGlobs {
    workspaces: Vec<Str>,
}
impl WorkspaceMemberGlobs {
    const fn new(workspaces: Vec<Str>) -> Self {
        Self { workspaces }
    }

    fn get_package_json_paths(
        self,
        workspace_root: impl AsRef<AbsolutePath>,
    ) -> Result<impl IntoIterator<Item = AbsolutePathBuf>, Error> {
        let workspace_root = workspace_root.as_ref();
        let mut package_json_paths = HashSet::<AbsolutePathBuf>::default();
        let mut has_negated = false;
        let mut inclusions = Vec::<Str>::new();
        let mut all = Vec::<Str>::new();
        for mut pattern in self.workspaces {
            pattern.push_str(if pattern.ends_with('/') { "package.json" } else { "/package.json" });
            if pattern.starts_with('!') {
                has_negated = true;
            } else {
                inclusions.push(pattern.clone());
            }
            all.push(pattern);
        }
        let glob_patterns = if has_negated { Some(GlobPatternSet::new(&all)?) } else { None };

        // TODO: parallelize this
        for inclusion in inclusions {
            let glob = Glob::new(&inclusion)?;
            for entry in glob.walk(workspace_root) {
                let Ok(entry) = entry else {
                    continue;
                };

                if !entry.file_type().is_file() {
                    continue;
                }

                if let Some(glob_patterns) = glob_patterns.as_ref()
                    && !glob_patterns.is_match(entry.to_candidate_path().as_ref())
                {
                    continue;
                }
                package_json_paths.insert(AbsolutePathBuf::new(entry.into_path()).unwrap());
            }
        }
        let mut package_json_paths = package_json_paths.into_iter().collect::<Vec<_>>();
        package_json_paths.sort_unstable();
        Ok(package_json_paths)
    }
}

#[derive(Debug, Clone)]
pub struct PackageInfo {
    pub package_json: PackageJson,
    pub path: RelativePathBuf,
    pub absolute_path: Arc<AbsolutePath>,
}

#[derive(Default)]
struct PackageGraphBuilder {
    id_and_deps_by_path: HashMap<RelativePathBuf, (PackageNodeIndex, Vec<(Str, DependencyType)>)>,
    name_to_path: HashMap<Str, SmallVec1<[RelativePathBuf; 1]>>,
    graph: DiGraph<PackageInfo, DependencyType, PackageIx>,
}

impl PackageGraphBuilder {
    fn add_package(
        &mut self,
        package_path: RelativePathBuf,
        absolute_path: Arc<AbsolutePath>,
        package_json: PackageJson,
    ) {
        let deps = package_json.get_workspace_dependencies().collect::<Vec<_>>();
        let package_name = package_json.name.clone();
        let id = self.graph.add_node(PackageInfo {
            package_json,
            path: package_path.clone(),
            absolute_path,
        });

        // Always store by path
        self.id_and_deps_by_path.insert(package_path.clone(), (id, deps));

        // Also maintain name to path mapping for dependency resolution
        match self.name_to_path.entry(package_name.clone()) {
            Entry::Vacant(entry) => {
                entry.insert(SmallVec1::new(package_path));
            }
            Entry::Occupied(mut entry) => {
                entry.get_mut().push(package_path);
            }
        }
    }

    fn build(mut self) -> Result<DiGraph<PackageInfo, DependencyType, PackageIx>, Error> {
        for (id, deps) in self.id_and_deps_by_path.values() {
            for (dep_name, dep_type) in deps {
                // Skip dependencies on nameless packages (empty string)
                // These can't be referenced anyway
                if dep_name.is_empty() {
                    continue;
                }

                // Resolve dependency name to path, then find the node
                if let Some(dep_paths) = self.name_to_path.get(dep_name)
                    && let Some((dep_id, _)) = self.id_and_deps_by_path.get(dep_paths.first())
                {
                    if let [dep_path1, dep_path2, ..] = dep_paths.as_slice() {
                        return Err(Error::DuplicatedPackageName {
                            name: dep_name.clone(),
                            path1: dep_path1.clone(),
                            path2: dep_path2.clone(),
                        });
                    }
                    self.graph.add_edge(*id, *dep_id, *dep_type);
                }
                // Silently skip if dependency not found - it might be an external package
            }
        }
        Ok(self.graph)
    }
}

/// newtype of `DefaultIx` for indices in package graphs
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PackageIx(DefaultIx);
unsafe impl petgraph::graph::IndexType for PackageIx {
    fn new(x: usize) -> Self {
        Self(DefaultIx::new(x))
    }

    fn index(&self) -> usize {
        self.0.index()
    }

    fn max() -> Self {
        Self(<DefaultIx as IndexType>::max())
    }
}

pub type PackageNodeIndex = NodeIndex<PackageIx>;
pub type PackageEdgeIndex = EdgeIndex<DefaultIx>;

/// Discover the workspace from cwd and load the package graph.
pub fn discover_package_graph(
    cwd: impl AsRef<AbsolutePath>,
) -> Result<DiGraph<PackageInfo, DependencyType, PackageIx>, Error> {
    let (workspace_root, _cwd) = find_workspace_root(cwd.as_ref())?;
    load_package_graph(&workspace_root)
}

/// Load the package graph from a discovered workspace.
pub fn load_package_graph(
    workspace_root: &WorkspaceRoot,
) -> Result<DiGraph<PackageInfo, DependencyType, PackageIx>, Error> {
    let mut graph_builder = PackageGraphBuilder::default();
    let workspaces = match &workspace_root.workspace_file {
        WorkspaceFile::PnpmWorkspaceYaml(file) => {
            let workspace: PnpmWorkspace = serde_yml::from_reader(file)?;
            workspace.packages
        }
        WorkspaceFile::NpmWorkspaceJson(file) => {
            let workspace: NpmWorkspace = serde_json::from_reader(file)?;
            workspace.workspaces
        }
        WorkspaceFile::NonWorkspacePackage(file) => {
            // For non-workspace packages, add the package.json to the graph as a root package
            let package_json: PackageJson = serde_json::from_reader(file)?;
            graph_builder.add_package(
                RelativePathBuf::default(),
                Arc::clone(&workspace_root.path),
                package_json,
            );

            return graph_builder.build();
        }
    };

    let member_globs = WorkspaceMemberGlobs::new(workspaces);
    let mut has_root_package = false;
    for package_json_path in member_globs.get_package_json_paths(&*workspace_root.path)? {
        let package_json: PackageJson = serde_json::from_slice(&fs::read(&package_json_path)?)?;
        let absolute_path = package_json_path.parent().unwrap();
        let Some(package_path) = absolute_path.strip_prefix(&*workspace_root.path)? else {
            return Err(Error::PackageOutsideWorkspace {
                package_path: package_json_path,
                workspace_root: workspace_root.path.to_absolute_path_buf(),
            });
        };

        has_root_package = has_root_package || package_path.as_str().is_empty();
        graph_builder.add_package(package_path, absolute_path.into(), package_json);
    }
    // try add the root package anyway if the member globs do not include it.
    if !has_root_package {
        let package_json_path = workspace_root.path.join("package.json");
        match fs::read(&package_json_path) {
            Ok(package_json) => {
                let package_json: PackageJson = serde_json::from_slice(&package_json)?;
                graph_builder.add_package(
                    RelativePathBuf::default(),
                    Arc::clone(&workspace_root.path),
                    package_json,
                );
            }
            Err(err) => {
                if err.kind() != io::ErrorKind::NotFound {
                    return Err(err.into());
                }
            }
        }
    }
    graph_builder.build()
}

#[cfg(test)]
mod tests {
    use std::{collections::HashSet, fs};

    use petgraph::visit::EdgeRef;
    use tempfile::TempDir;

    use super::*;

    #[test]
    fn test_get_package_graph_single_package() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create a single package.json without workspaces
        let package_json = serde_json::json!({
            "name": "my-app",
            "dependencies": {
                "react": "^18.0.0"
            },
            "devDependencies": {
                "typescript": "^5.0.0"
            }
        });
        fs::write(temp_dir_path.join("package.json"), package_json.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have exactly 1 node (the single package)
        assert_eq!(graph.node_count(), 1);
        assert_eq!(graph.edge_count(), 0);

        let node = graph.node_weight(NodeIndex::new(0)).unwrap();
        assert_eq!(node.package_json.name, "my-app");
        assert_eq!(node.path.as_str(), "");
    }

    #[test]
    fn test_get_package_graph_pnpm_workspace() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create root package.json
        let root_package = serde_json::json!({
            "name": "monorepo-root",
            "private": true
        });
        fs::write(temp_dir_path.join("package.json"), root_package.to_string()).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create package A
        fs::create_dir_all(temp_dir_path.join("packages/pkg-a")).unwrap();
        let pkg_a = serde_json::json!({
            "name": "pkg-a",
            "dependencies": {}
        });
        fs::write(temp_dir_path.join("packages/pkg-a/package.json"), pkg_a.to_string()).unwrap();

        // Create package B that depends on A
        fs::create_dir_all(temp_dir_path.join("packages/pkg-b")).unwrap();
        let pkg_b = serde_json::json!({
            "name": "pkg-b",
            "dependencies": {
                "pkg-a": "workspace:*"
            }
        });
        fs::write(temp_dir_path.join("packages/pkg-b/package.json"), pkg_b.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have 3 nodes: root + pkg-a + pkg-b
        assert_eq!(graph.node_count(), 3);
        // Should have 1 edge: pkg-b -> pkg-a
        assert_eq!(graph.edge_count(), 1);

        // Verify the dependency edge exists
        let mut found_edge = false;
        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];
            if source.package_json.name == "pkg-b" && target.package_json.name == "pkg-a" {
                found_edge = true;
                assert_eq!(*edge_ref.weight(), DependencyType::Normal);
            }
        }
        assert!(found_edge, "Should have found edge from pkg-b to pkg-a");
    }

    #[test]
    fn test_get_package_graph_workspace_exclusions() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();
        let workspace_yaml = r#"packages:
  - "packages/*"
  - "!packages/excluded*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create included package
        fs::create_dir_all(temp_dir_path.join("packages/included")).unwrap();
        let included = serde_json::json!({
            "name": "included-pkg"
        });
        fs::write(temp_dir_path.join("packages/included/package.json"), included.to_string())
            .unwrap();

        // Create excluded package
        fs::create_dir_all(temp_dir_path.join("packages/excluded-test")).unwrap();
        let excluded = serde_json::json!({
            "name": "excluded-pkg"
        });
        fs::write(temp_dir_path.join("packages/excluded-test/package.json"), excluded.to_string())
            .unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have the included package
        let mut found_included = false;
        let mut found_excluded = false;
        for node in graph.node_weights() {
            if node.package_json.name == "included-pkg" {
                found_included = true;
            }
            if node.package_json.name == "excluded-pkg" {
                found_excluded = true;
            }
        }
        assert!(found_included, "Should have found included package");
        assert!(!found_excluded, "Should not have found excluded package");
    }

    #[test]
    fn test_get_package_graph_workspace_work_with_last_match_wins() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();
        let workspace_yaml = r#"packages:
  - "packages/**"
  - "!packages/excluded/**"
  - "packages/excluded/a"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create included package
        fs::create_dir_all(temp_dir_path.join("packages/included")).unwrap();
        let included = serde_json::json!({
            "name": "included-pkg"
        });
        fs::write(temp_dir_path.join("packages/included/package.json"), included.to_string())
            .unwrap();

        // Create excluded package b
        fs::create_dir_all(temp_dir_path.join("packages/excluded/b")).unwrap();
        let excluded = serde_json::json!({
            "name": "excluded-b"
        });
        fs::write(temp_dir_path.join("packages/excluded/b/package.json"), excluded.to_string())
            .unwrap();

        // Create included package a
        fs::create_dir_all(temp_dir_path.join("packages/excluded/a")).unwrap();
        let excluded = serde_json::json!({
            "name": "excluded-a"
        });
        fs::write(temp_dir_path.join("packages/excluded/a/package.json"), excluded.to_string())
            .unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have the included package
        let mut found_included = false;
        let mut found_b = false;
        let mut found_a = false;
        for node in graph.node_weights() {
            if node.package_json.name == "included-pkg" {
                found_included = true;
            }
            if node.package_json.name == "excluded-b" {
                found_b = true;
            }
            if node.package_json.name == "excluded-a" {
                found_a = true;
            }
        }
        assert!(found_included, "Should have found included package");
        assert!(!found_b, "Should not have found excluded package b");
        assert!(found_a, "Should have found included package a");
    }

    #[test]
    fn test_get_package_graph_dev_and_peer_deps() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create package A
        fs::create_dir_all(temp_dir_path.join("packages/pkg-a")).unwrap();
        let pkg_a = serde_json::json!({
            "name": "pkg-a"
        });
        fs::write(temp_dir_path.join("packages/pkg-a/package.json"), pkg_a.to_string()).unwrap();

        // Create package B
        fs::create_dir_all(temp_dir_path.join("packages/pkg-b")).unwrap();
        let pkg_b = serde_json::json!({
            "name": "pkg-b"
        });
        fs::write(temp_dir_path.join("packages/pkg-b/package.json"), pkg_b.to_string()).unwrap();

        // Create package C that depends on A and B with different types
        fs::create_dir_all(temp_dir_path.join("packages/pkg-c")).unwrap();
        let pkg_c = serde_json::json!({
            "name": "pkg-c",
            "dependencies": {
                "pkg-a": "workspace:*"
            },
            "devDependencies": {
                "pkg-b": "workspace:^1.0.0"
            }
        });
        fs::write(temp_dir_path.join("packages/pkg-c/package.json"), pkg_c.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have correct edge types
        let mut found_normal_dep = false;
        let mut found_dev_dep = false;
        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];

            if source.package_json.name == "pkg-c" && target.package_json.name == "pkg-a" {
                assert_eq!(*edge_ref.weight(), DependencyType::Normal);
                found_normal_dep = true;
            }
            if source.package_json.name == "pkg-c" && target.package_json.name == "pkg-b" {
                assert_eq!(*edge_ref.weight(), DependencyType::Dev);
                found_dev_dep = true;
            }
        }
        assert!(found_normal_dep, "Should have found normal dependency");
        assert!(found_dev_dep, "Should have found dev dependency");
    }

    #[test]
    fn test_get_package_graph_duplicate_names() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create first package with name "duplicate"
        fs::create_dir_all(temp_dir_path.join("packages/pkg-1")).unwrap();
        let pkg_1 = serde_json::json!({
            "name": "duplicate"
        });
        fs::write(temp_dir_path.join("packages/pkg-1/package.json"), pkg_1.to_string()).unwrap();

        // Create second package with same name "duplicate"
        fs::create_dir_all(temp_dir_path.join("packages/pkg-2")).unwrap();
        let pkg_2 = serde_json::json!({
            "name": "duplicate"
        });
        fs::write(temp_dir_path.join("packages/pkg-2/package.json"), pkg_2.to_string()).unwrap();

        // duplicate package names is allowed.
        let result = discover_package_graph(temp_dir_path);
        assert!(result.is_ok());
    }

    #[test]
    fn test_get_package_graph_nameless_packages() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create package without name
        fs::create_dir_all(temp_dir_path.join("packages/nameless")).unwrap();
        let nameless = serde_json::json!({
            "dependencies": {
                "some-lib": "^1.0.0"
            }
        });
        fs::write(temp_dir_path.join("packages/nameless/package.json"), nameless.to_string())
            .unwrap();

        // Create package that tries to depend on nameless package
        fs::create_dir_all(temp_dir_path.join("packages/pkg-a")).unwrap();
        let pkg_a = serde_json::json!({
            "name": "pkg-a",
            "dependencies": {
                "": "workspace:*"  // Trying to depend on nameless package
            }
        });
        fs::write(temp_dir_path.join("packages/pkg-a/package.json"), pkg_a.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have 2 nodes but no edges (nameless package can't be referenced)
        assert_eq!(graph.node_count(), 2);
        assert_eq!(graph.edge_count(), 0);
    }

    #[test]
    fn test_get_package_graph_workspace_protocol_with_version() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create package A
        fs::create_dir_all(temp_dir_path.join("packages/pkg-a")).unwrap();
        let pkg_a = serde_json::json!({
            "name": "@scope/pkg-a",
            "version": "1.0.0"
        });
        fs::write(temp_dir_path.join("packages/pkg-a/package.json"), pkg_a.to_string()).unwrap();

        // Create package B that depends on A with specific workspace version
        fs::create_dir_all(temp_dir_path.join("packages/pkg-b")).unwrap();
        let pkg_b = serde_json::json!({
            "name": "pkg-b",
            "dependencies": {
                "@scope/pkg-a": "workspace:@scope/pkg-a@^1.0.0"
            }
        });
        fs::write(temp_dir_path.join("packages/pkg-b/package.json"), pkg_b.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should correctly parse workspace protocol with version
        let mut found_edge = false;
        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];
            if source.package_json.name == "pkg-b" && target.package_json.name == "@scope/pkg-a" {
                found_edge = true;
            }
        }
        assert!(found_edge, "Should have found edge from pkg-b to @scope/pkg-a");
    }

    #[test]
    fn test_get_package_graph_circular_dependencies() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create package A that depends on B
        fs::create_dir_all(temp_dir_path.join("packages/pkg-a")).unwrap();
        let pkg_a = serde_json::json!({
            "name": "pkg-a",
            "dependencies": {
                "pkg-b": "workspace:*"
            }
        });
        fs::write(temp_dir_path.join("packages/pkg-a/package.json"), pkg_a.to_string()).unwrap();

        // Create package B that depends on A (circular)
        fs::create_dir_all(temp_dir_path.join("packages/pkg-b")).unwrap();
        let pkg_b = serde_json::json!({
            "name": "pkg-b",
            "dependencies": {
                "pkg-a": "workspace:*"
            }
        });
        fs::write(temp_dir_path.join("packages/pkg-b/package.json"), pkg_b.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have 2 nodes and 2 edges (circular)
        assert_eq!(graph.node_count(), 2);
        assert_eq!(graph.edge_count(), 2);

        // Verify both edges exist
        let mut found_a_to_b = false;
        let mut found_b_to_a = false;
        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];

            if source.package_json.name == "pkg-a" && target.package_json.name == "pkg-b" {
                found_a_to_b = true;
            }
            if source.package_json.name == "pkg-b" && target.package_json.name == "pkg-a" {
                found_b_to_a = true;
            }
        }
        assert!(found_a_to_b && found_b_to_a, "Should have found circular dependencies");
    }

    #[test]
    fn test_get_package_graph_missing_root_package_with_globs() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create pnpm-workspace.yaml that doesn't include root
        let workspace_yaml = r#"packages:
  - "packages/*"
"#;
        fs::write(temp_dir_path.join("pnpm-workspace.yaml"), workspace_yaml).unwrap();

        // Create root package.json that won't be included by glob
        let root_package = serde_json::json!({
            "name": "root",
            "private": true
        });
        fs::write(temp_dir_path.join("package.json"), root_package.to_string()).unwrap();

        // Create packages directory with one package
        fs::create_dir_all(temp_dir_path.join("packages/pkg-a")).unwrap();
        let pkg_a = serde_json::json!({
            "name": "pkg-a"
        });
        fs::write(temp_dir_path.join("packages/pkg-a/package.json"), pkg_a.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have both root and pkg-a (root added automatically)
        assert_eq!(graph.node_count(), 2);

        let mut found_root = false;
        let mut found_pkg_a = false;
        for node in graph.node_weights() {
            if node.package_json.name == "root" && node.path.as_str() == "" {
                found_root = true;
            }
            if node.package_json.name == "pkg-a" {
                found_pkg_a = true;
            }
        }
        assert!(found_root, "Should have found root package");
        assert!(found_pkg_a, "Should have found pkg-a");
    }

    #[test]
    fn test_get_package_graph_npm_workspace() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create package.json with workspaces field (npm workspace)
        let root_package = serde_json::json!({
            "name": "npm-monorepo",
            "private": true,
            "workspaces": ["packages/*", "apps/*"]
        });
        fs::write(temp_dir_path.join("package.json"), root_package.to_string()).unwrap();

        // Create packages directory structure
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();
        fs::create_dir_all(temp_dir_path.join("apps")).unwrap();

        // Create shared library package
        fs::create_dir_all(temp_dir_path.join("packages/shared")).unwrap();
        let shared_pkg = serde_json::json!({
            "name": "@myorg/shared",
            "version": "1.0.0"
        });
        fs::write(temp_dir_path.join("packages/shared/package.json"), shared_pkg.to_string())
            .unwrap();

        // Create UI library that depends on shared
        fs::create_dir_all(temp_dir_path.join("packages/ui")).unwrap();
        let ui_pkg = serde_json::json!({
            "name": "@myorg/ui",
            "version": "1.0.0",
            "dependencies": {
                "@myorg/shared": "workspace:*"
            }
        });
        fs::write(temp_dir_path.join("packages/ui/package.json"), ui_pkg.to_string()).unwrap();

        // Create app that depends on both packages
        fs::create_dir_all(temp_dir_path.join("apps/web")).unwrap();
        let web_app = serde_json::json!({
            "name": "web-app",
            "version": "0.1.0",
            "dependencies": {
                "@myorg/shared": "workspace:*",
                "@myorg/ui": "workspace:^1.0.0"
            }
        });
        fs::write(temp_dir_path.join("apps/web/package.json"), web_app.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have 4 nodes: root + shared + ui + web-app
        assert_eq!(graph.node_count(), 4);

        // Verify packages were found
        let mut packages_found = HashSet::<String>::new();
        for node in graph.node_weights() {
            packages_found.insert(node.package_json.name.to_string());
        }
        assert!(packages_found.contains("npm-monorepo"));
        assert!(packages_found.contains("@myorg/shared"));
        assert!(packages_found.contains("@myorg/ui"));
        assert!(packages_found.contains("web-app"));

        // Verify dependency edges
        let mut found_ui_to_shared = false;
        let mut found_web_to_shared = false;
        let mut found_web_to_ui = false;

        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];

            if source.package_json.name == "@myorg/ui"
                && target.package_json.name == "@myorg/shared"
            {
                found_ui_to_shared = true;
            }
            if source.package_json.name == "web-app" && target.package_json.name == "@myorg/shared"
            {
                found_web_to_shared = true;
            }
            if source.package_json.name == "web-app" && target.package_json.name == "@myorg/ui" {
                found_web_to_ui = true;
            }
        }

        assert!(found_ui_to_shared, "UI should depend on shared");
        assert!(found_web_to_shared, "Web app should depend on shared");
        assert!(found_web_to_ui, "Web app should depend on UI");
    }

    #[test]
    fn test_get_package_graph_yarn_workspace() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create package.json with workspaces field (yarn workspace)
        // Using the simple array format which is compatible with both yarn and npm
        let root_package = serde_json::json!({
            "name": "yarn-monorepo",
            "private": true,
            "workspaces": ["packages/*"]
        });
        fs::write(temp_dir_path.join("package.json"), root_package.to_string()).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create core package
        fs::create_dir_all(temp_dir_path.join("packages/core")).unwrap();
        let core_pkg = serde_json::json!({
            "name": "core",
            "version": "2.0.0"
        });
        fs::write(temp_dir_path.join("packages/core/package.json"), core_pkg.to_string()).unwrap();

        // Create utils package that has peer dependency on core
        fs::create_dir_all(temp_dir_path.join("packages/utils")).unwrap();
        let utils_pkg = serde_json::json!({
            "name": "utils",
            "version": "1.5.0",
            "peerDependencies": {
                "core": "workspace:^2.0.0"
            }
        });
        fs::write(temp_dir_path.join("packages/utils/package.json"), utils_pkg.to_string())
            .unwrap();

        // Create cli package that depends on both
        fs::create_dir_all(temp_dir_path.join("packages/cli")).unwrap();
        let cli_pkg = serde_json::json!({
            "name": "cli-tool",
            "version": "0.5.0",
            "dependencies": {
                "core": "workspace:*"
            },
            "devDependencies": {
                "utils": "workspace:*"
            }
        });
        fs::write(temp_dir_path.join("packages/cli/package.json"), cli_pkg.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Should have 4 nodes: root + core + utils + cli-tool
        assert_eq!(graph.node_count(), 4);

        // Verify all packages were found
        let mut packages_found = HashSet::<String>::new();
        for node in graph.node_weights() {
            packages_found.insert(node.package_json.name.to_string());
        }
        assert!(packages_found.contains("yarn-monorepo"));
        assert!(packages_found.contains("core"));
        assert!(packages_found.contains("utils"));
        assert!(packages_found.contains("cli-tool"));

        // Verify dependency edges and their types
        let mut found_utils_peer_core = false;
        let mut found_cli_dep_core = false;
        let mut found_cli_dev_utils = false;

        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];

            if source.package_json.name == "utils" && target.package_json.name == "core" {
                assert_eq!(*edge_ref.weight(), DependencyType::Peer);
                found_utils_peer_core = true;
            }
            if source.package_json.name == "cli-tool" && target.package_json.name == "core" {
                assert_eq!(*edge_ref.weight(), DependencyType::Normal);
                found_cli_dep_core = true;
            }
            if source.package_json.name == "cli-tool" && target.package_json.name == "utils" {
                assert_eq!(*edge_ref.weight(), DependencyType::Dev);
                found_cli_dev_utils = true;
            }
        }

        assert!(found_utils_peer_core, "Utils should have peer dependency on core");
        assert!(found_cli_dep_core, "CLI should depend on core");
        assert!(found_cli_dev_utils, "CLI should have dev dependency on utils");
    }

    #[test]
    fn test_get_package_graph_npm_workspace_with_exclusions() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create package.json with workspaces field including exclusions
        let root_package = serde_json::json!({
            "name": "npm-workspace-exclusions",
            "private": true,
            "workspaces": [
                "packages/*",
                "!packages/experimental",
                "!packages/*.backup"
            ]
        });
        fs::write(temp_dir_path.join("package.json"), root_package.to_string()).unwrap();

        // Create packages directory
        fs::create_dir_all(temp_dir_path.join("packages")).unwrap();

        // Create normal package
        fs::create_dir_all(temp_dir_path.join("packages/normal")).unwrap();
        let normal_pkg = serde_json::json!({
            "name": "normal-package"
        });
        fs::write(temp_dir_path.join("packages/normal/package.json"), normal_pkg.to_string())
            .unwrap();

        // Create experimental package (should be excluded)
        fs::create_dir_all(temp_dir_path.join("packages/experimental")).unwrap();
        let experimental_pkg = serde_json::json!({
            "name": "experimental-package"
        });
        fs::write(
            temp_dir_path.join("packages/experimental/package.json"),
            experimental_pkg.to_string(),
        )
        .unwrap();

        // Create backup package (should be excluded by pattern)
        fs::create_dir_all(temp_dir_path.join("packages/old.backup")).unwrap();
        let backup_pkg = serde_json::json!({
            "name": "backup-package"
        });
        fs::write(temp_dir_path.join("packages/old.backup/package.json"), backup_pkg.to_string())
            .unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Check which packages were included
        let mut packages_found = HashSet::<String>::new();
        for node in graph.node_weights() {
            packages_found.insert(node.package_json.name.to_string());
        }

        assert!(packages_found.contains("npm-workspace-exclusions"), "Root should be included");
        assert!(packages_found.contains("normal-package"), "Normal package should be included");

        // Note: As identified in the pnpm exclusion test, exclusions might not work correctly
        // with the current implementation. This test documents the expected behavior.
    }

    #[test]
    fn test_get_package_graph_mixed_workspace_protocols() {
        let temp_dir = TempDir::new().unwrap();
        let temp_dir_path = AbsolutePath::new(temp_dir.path()).unwrap();

        // Create package.json with workspaces (npm/yarn style)
        let root_package = serde_json::json!({
            "name": "mixed-protocols",
            "private": true,
            "workspaces": ["libs/*", "services/*"]
        });
        fs::write(temp_dir_path.join("package.json"), root_package.to_string()).unwrap();

        // Create directory structure
        fs::create_dir_all(temp_dir_path.join("libs")).unwrap();
        fs::create_dir_all(temp_dir_path.join("services")).unwrap();

        // Create a library with specific version
        fs::create_dir_all(temp_dir_path.join("libs/database")).unwrap();
        let db_pkg = serde_json::json!({
            "name": "@company/database",
            "version": "3.2.1"
        });
        fs::write(temp_dir_path.join("libs/database/package.json"), db_pkg.to_string()).unwrap();

        // Create service with various workspace protocol formats
        fs::create_dir_all(temp_dir_path.join("services/api")).unwrap();
        let api_pkg = serde_json::json!({
            "name": "api-service",
            "dependencies": {
                // Different workspace protocol formats
                "@company/database": "workspace:*",
                "external-lib": "^1.0.0"  // External dependency (not workspace)
            }
        });
        fs::write(temp_dir_path.join("services/api/package.json"), api_pkg.to_string()).unwrap();

        let graph = discover_package_graph(temp_dir_path).unwrap();

        // Verify packages
        assert_eq!(graph.node_count(), 3); // root + database + api

        // Verify workspace dependency exists but not external dependency
        let mut found_workspace_dep = false;
        for edge_ref in graph.edge_references() {
            let source = &graph[edge_ref.source()];
            let target = &graph[edge_ref.target()];

            if source.package_json.name == "api-service"
                && target.package_json.name == "@company/database"
            {
                found_workspace_dep = true;
            }
        }

        assert!(found_workspace_dep, "Should have found workspace dependency");

        // External dependencies should not create edges
        assert_eq!(graph.edge_count(), 1, "Should only have one edge for workspace dependency");
    }
}