feat: add yanked version substitution, MODULE.tools support, and Bazel compatibility

This commit adds several enhancements to improve Bazel compatibility and
module resolution accuracy:

1. Yanked Version Substitution
   - Added SubstituteYanked option to automatically replace yanked versions
     with non-yanked alternatives in the same compatibility level
   - Matches Bazel's default behavior for handling yanked versions
   - Added findNonYankedVersion() to locate suitable replacements
   - Fixed map iteration bug in substituteYankedVersionsInGraph()

2. MODULE.tools Dependencies (bazeltools package)
   - New bazeltools package provides Bazel version-specific MODULE.tools deps
   - Supports Bazel versions: 6.6.0, 7.0.0, 7.1.0, 7.2.0, 8.0.0, 9.0.0
   - Added BazelVersion option to inject implicit tool dependencies
   - Improved ClosestVersion() to correctly parse version strings
   - Ensures resolution matches Bazel's behavior for a given version

3. Selection API Enhancements
   - Added SelectionResolver for full Bazel-compatible resolution
   - New ResolveWithSelection() API with compatibility level enforcement
   - Fixed buildDepGraph() concurrency issues with proper synchronization
   - Added SelectionResult with resolved, unpruned, and BFS order views

4. Type System Extensions
   - Added ResolutionOptions.SubstituteYanked for yanked substitution
   - Added ResolutionOptions.BazelVersion for MODULE.tools injection
   - Added SelectionResult type with resolved/unpruned graph views
   - Added NodepDeps support in selection.Module for Bazel 7.6+

5. Registry & Metadata
   - Added NonYankedVersions() method to registry.Metadata
   - Enhanced GetModuleMetadata() with caching support

6. Tests & Documentation
   - Added yanked_test.go with comprehensive yanked version tests
   - Added selection_api_test.go for selection resolver tests
   - Added max_compatibility_level tests in selection package
   - Added nodep_deps tests for Bazel 7.6+ behavior
   - Updated e2e tests to use MODULE.tools dependencies

Bug Fixes:
- Fixed map modification during iteration in substituteYankedVersionsInGraph
- Fixed buildDepGraph queue handling to prevent premature exit
- Fixed ClosestVersion to properly parse major.minor versions

Author: albertocavalcante

api.go

@@ -11,7 +11,7 @@
 //
 //   - Parser: Parses MODULE.bazel files to extract module information
 //   - Registry: Fetches module metadata from Bazel Central Registry (BCR)
-//   - Resolver: Resolves transitive dependencies using MVS
+//   - Resolver: Resolves transitive dependencies using MVS or Bazel's selection algorithm
 //
 // # Quick Start
 //
@@ -29,16 +29,39 @@
 //	    fmt.Printf("%s@%s\n", mod.Name, mod.Version)
 //	}
 //
+// # Selection API (Full Bazel Compatibility)
+//
+// For full Bazel compatibility including compatibility levels and proper pruning:
+//
+//	opts := gobzlmod.ResolutionOptions{
+//	    IncludeDevDeps: false,
+//	    CheckYanked:    true,
+//	    YankedBehavior: gobzlmod.YankedVersionWarn,
+//	}
+//	result, err := gobzlmod.ResolveWithSelection(ctx, moduleContent, registryURL, opts)
+//
+// # Yanked Version Handling
+//
+// The library supports detecting and handling yanked versions from the registry:
+//
+//	opts := gobzlmod.ResolutionOptions{
+//	    CheckYanked:    true,                        // Enable yanked version checking
+//	    YankedBehavior: gobzlmod.YankedVersionError, // Fail if yanked versions selected
+//	}
+//
+// YankedBehavior options:
+//   - YankedVersionAllow: Populate yanked info but don't warn or error
+//   - YankedVersionWarn: Include warnings in result for yanked versions
+//   - YankedVersionError: Return error if any yanked version is selected
+//
 // # Differences from Bazel's Algorithm
 //
-// Bazel's actual resolution algorithm includes additional features not implemented here:
+// The simple MVS resolver differs from Bazel's algorithm in:
 //   - Compatibility level checking and automatic upgrades
-//   - Yanked version handling
 //   - Multiple version override support
 //   - Module extension resolution
 //
-// For production use requiring full Bazel compatibility, see the selection package
-// which implements Bazel's complete algorithm.
+// Use ResolveWithSelection for compatibility level enforcement and proper pruning.
 //
 // # Thread Safety
 //
@@ -80,3 +103,46 @@ func ResolveDependenciesWithContext(ctx context.Context, moduleContent, registry
 	resolver := NewDependencyResolver(registry, includeDevDeps)
 	return resolver.ResolveDependencies(ctx, moduleInfo)
 }
+
+// ResolveDependenciesWithOptions resolves dependencies with full configuration control.
+// This allows enabling yanked version checking and other advanced options.
+func ResolveDependenciesWithOptions(ctx context.Context, moduleContent, registryURL string, opts ResolutionOptions) (*ResolutionList, error) {
+	moduleInfo, err := ParseModuleContent(moduleContent)
+	if err != nil {
+		return nil, fmt.Errorf("parse module content: %w", err)
+	}
+
+	registry := NewRegistryClient(registryURL)
+	resolver := NewDependencyResolverWithOptions(registry, opts)
+	return resolver.ResolveDependencies(ctx, moduleInfo)
+}
+
+// ResolveWithSelection resolves dependencies using Bazel's complete selection algorithm.
+// This provides full compatibility with Bazel including:
+//   - Compatibility level enforcement
+//   - Multiple version override support (when available in Override type)
+//   - Proper pruning of unreachable modules
+//
+// Returns a SelectionResult with both resolved and unpruned views.
+func ResolveWithSelection(ctx context.Context, moduleContent, registryURL string, opts ResolutionOptions) (*SelectionResult, error) {
+	moduleInfo, err := ParseModuleContent(moduleContent)
+	if err != nil {
+		return nil, fmt.Errorf("parse module content: %w", err)
+	}
+
+	registry := NewRegistryClient(registryURL)
+	resolver := NewSelectionResolver(registry, opts)
+	return resolver.Resolve(ctx, moduleInfo)
+}
+
+// ResolveWithSelectionFromFile loads a MODULE.bazel file and resolves using the selection algorithm.
+func ResolveWithSelectionFromFile(moduleFilePath, registryURL string, opts ResolutionOptions) (*SelectionResult, error) {
+	moduleInfo, err := ParseModuleFile(moduleFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("parse module file: %w", err)
+	}
+
+	registry := NewRegistryClient(registryURL)
+	resolver := NewSelectionResolver(registry, opts)
+	return resolver.Resolve(context.Background(), moduleInfo)
+}

bazeltools/tools.go

@@ -0,0 +1,197 @@
+// Package bazeltools provides Bazel version-specific MODULE.tools dependencies.
+// These are the implicit dependencies that Bazel adds to every resolution.
+package bazeltools
+
+// ToolDep represents a dependency from Bazel's MODULE.tools file.
+type ToolDep struct {
+	Name    string
+	Version string
+}
+
+// VersionConfig contains the MODULE.tools dependencies for a specific Bazel version.
+type VersionConfig struct {
+	// BazelVersion is the Bazel version (e.g., "7.0.0").
+	BazelVersion string
+	// Deps are the dependencies declared in MODULE.tools.
+	Deps []ToolDep
+}
+
+// bazelConfigs maps Bazel versions to their MODULE.tools dependencies.
+var bazelConfigs = map[string]VersionConfig{
+	"6.6.0": {
+		BazelVersion: "6.6.0",
+		Deps: []ToolDep{
+			{"rules_cc", "0.0.9"},
+			{"rules_java", "5.5.1"},
+			{"rules_license", "0.0.3"},
+			{"rules_proto", "4.0.0"},
+			{"rules_python", "0.4.0"},
+			{"platforms", "0.0.7"},
+			{"protobuf", "3.19.6"},
+			{"zlib", "1.2.13"},
+		},
+	},
+	"7.0.0": {
+		BazelVersion: "7.0.0",
+		Deps: []ToolDep{
+			{"rules_cc", "0.0.9"},
+			{"rules_java", "7.1.0"},
+			{"rules_license", "0.0.3"},
+			{"rules_proto", "4.0.0"},
+			{"rules_python", "0.4.0"},
+			{"platforms", "0.0.7"},
+			{"protobuf", "3.19.6"},
+			{"zlib", "1.3"},
+			{"apple_support", "1.5.0"},
+		},
+	},
+	"7.1.0": {
+		BazelVersion: "7.1.0",
+		Deps: []ToolDep{
+			{"rules_cc", "0.0.9"},
+			{"rules_java", "7.4.0"},
+			{"rules_license", "0.0.7"},
+			{"rules_proto", "5.3.0-21.7"},
+			{"rules_python", "0.31.0"},
+			{"platforms", "0.0.8"},
+			{"protobuf", "21.7"},
+			{"zlib", "1.3.1"},
+			{"apple_support", "1.11.1"},
+		},
+	},
+	"7.2.0": {
+		BazelVersion: "7.2.0",
+		Deps: []ToolDep{
+			{"rules_cc", "0.0.9"},
+			{"rules_java", "7.6.1"},
+			{"rules_license", "0.0.7"},
+			{"rules_proto", "6.0.0"},
+			{"rules_python", "0.32.2"},
+			{"platforms", "0.0.9"},
+			{"protobuf", "27.0"},
+			{"zlib", "1.3.1.bcr.1"},
+			{"apple_support", "1.15.1"},
+		},
+	},
+	"8.0.0": {
+		BazelVersion: "8.0.0",
+		Deps: []ToolDep{
+			{"rules_license", "1.0.0"},
+			{"buildozer", "7.1.2"},
+			{"platforms", "0.0.10"},
+			{"zlib", "1.3.1.bcr.3"},
+			{"rules_proto", "7.0.2"},
+			{"bazel_features", "1.21.0"},
+			{"protobuf", "29.0"},
+			{"rules_java", "8.6.1"},
+			{"rules_cc", "0.0.16"},
+			{"rules_python", "0.40.0"},
+			{"rules_shell", "0.2.0"},
+		},
+	},
+	"9.0.0": {
+		BazelVersion: "9.0.0",
+		Deps: []ToolDep{
+			{"rules_license", "1.0.0"},
+			{"buildozer", "8.2.1"},
+			{"platforms", "1.0.0"},
+			{"zlib", "1.3.1.bcr.5"},
+			{"bazel_features", "1.30.0"},
+			{"protobuf", "33.4"},
+			{"rules_java", "9.0.3"},
+			{"rules_cc", "0.2.14"},
+			{"rules_python", "1.7.0"},
+			{"rules_shell", "0.6.1"},
+			{"apple_support", "1.24.2"},
+			{"rules_apple", "4.1.0"},
+			{"rules_swift", "3.1.2"},
+			{"abseil-cpp", "20250814.1"},
+		},
+	},
+}
+
+// GetConfig returns the MODULE.tools configuration for a Bazel version.
+// Returns nil if the version is not supported.
+// Use ClosestVersion to find the closest matching version.
+func GetConfig(version string) *VersionConfig {
+	if cfg, ok := bazelConfigs[version]; ok {
+		return &cfg
+	}
+	return nil
+}
+
+// GetDeps returns the MODULE.tools dependencies for a Bazel version.
+// Returns nil if the version is not supported.
+func GetDeps(version string) []ToolDep {
+	if cfg := GetConfig(version); cfg != nil {
+		return cfg.Deps
+	}
+	return nil
+}
+
+// SupportedVersions returns all supported Bazel versions.
+func SupportedVersions() []string {
+	versions := make([]string, 0, len(bazelConfigs))
+	for v := range bazelConfigs {
+		versions = append(versions, v)
+	}
+	return versions
+}
+
+const (
+	// versionMinLenMajorMinor is the minimum length for major.minor pattern (e.g., "7.0.x").
+	versionMinLenMajorMinor = 5
+)
+
+// ClosestVersion finds the closest supported version for a given Bazel version.
+// For example, "7.0.1" would return "7.0.0", "7.1.2" would return "7.1.0".
+// Returns empty string if no suitable version is found.
+func ClosestVersion(version string) string {
+	// Exact match
+	if _, ok := bazelConfigs[version]; ok {
+		return version
+	}
+
+	// Try major.minor.0 pattern - find the first two dots
+	// For "7.0.1" -> "7.0.0", for "7.1.2" -> "7.1.0"
+	if len(version) >= versionMinLenMajorMinor {
+		firstDot := -1
+		secondDot := -1
+		for i, c := range version {
+			if c == '.' {
+				if firstDot == -1 {
+					firstDot = i
+				} else {
+					secondDot = i
+					break
+				}
+			}
+		}
+		if firstDot > 0 && secondDot > firstDot {
+			majorMinor := version[:secondDot] + ".0" // e.g., "7.0.1" -> "7.0.0"
+			if _, ok := bazelConfigs[majorMinor]; ok {
+				return majorMinor
+			}
+		}
+	}
+
+	// Try major.0.0 pattern
+	if len(version) >= 1 {
+		// Find first dot to get major version
+		firstDot := -1
+		for i, c := range version {
+			if c == '.' {
+				firstDot = i
+				break
+			}
+		}
+		if firstDot > 0 {
+			major := version[:firstDot] + ".0.0" // e.g., "7.x.x" -> "7.0.0"
+			if _, ok := bazelConfigs[major]; ok {
+				return major
+			}
+		}
+	}
+
+	return ""
+}

e2e/e2e_test.go

@@ -26,8 +26,18 @@ type BazelModGraph = graph.BazelModGraph
 
 // resolveDependencies uses our library API to resolve dependencies
 func resolveDependencies(content, registry string, includeDevDeps bool) (*ResolutionList, error) {
-	// Use the library API directly instead of building a binary
-	resolutionList, err := gobzlmod.ResolveDependenciesFromContent(content, registry, includeDevDeps)
+	return resolveDependenciesWithBazelVersion(content, registry, includeDevDeps, "7.0.0")
+}
+
+// resolveDependenciesWithBazelVersion resolves with a specific Bazel version for MODULE.tools compat
+func resolveDependenciesWithBazelVersion(content, registry string, includeDevDeps bool, bazelVersion string) (*ResolutionList, error) {
+	opts := gobzlmod.ResolutionOptions{
+		IncludeDevDeps:   includeDevDeps,
+		SubstituteYanked: true,
+		BazelVersion:     bazelVersion,
+	}
+	ctx := context.Background()
+	resolutionList, err := gobzlmod.ResolveDependenciesWithOptions(ctx, content, registry, opts)
 	if err != nil {
 		return nil, fmt.Errorf("failed to resolve dependencies: %v", err)
 	}
@@ -128,18 +138,8 @@ func runBazelModGraph(t *testing.T, workspaceDir string) (*BazelModGraph, error)
 func flattenBazelGraph(graph *BazelModGraph) []BazelModuleInfo {
 	modules := make(map[string]BazelModuleInfo)
 
-	// Add root module if it has name and version
-	if graph.Name != "" && graph.Version != "" {
-		key := graph.Key
-		if key == "" {
-			key = graph.Name + "@" + graph.Version
-		}
-		modules[key] = BazelModuleInfo{
-			Key:     key,
-			Name:    graph.Name,
-			Version: graph.Version,
-		}
-	}
+	// Skip root module - we only compare dependencies
+	// The root module has Key="<root>" and is not a dependency
 
 	// Recursively process dependencies
 	var processDeps func(deps []BazelDependency)
@@ -195,7 +195,7 @@ func compareModuleLists(t *testing.T, ourModules []ModuleToResolve, bazelModules
 	bazelModuleMap := make(map[string]BazelModuleInfo)
 	for _, module := range bazelModules {
 		key := normalizeModuleName(module.Name)
-		// Skip root module and empty names
+		// Skip empty names and internal references
 		if key == "" || strings.Contains(key, "<root>") || strings.Contains(key, "@@") {
 			continue
 		}

parser.go

@@ -55,10 +55,11 @@ func extractModuleInfo(f *build.File) *ModuleInfo {
 
 		case "bazel_dep":
 			dep := Dependency{
-				Name:          buildutil.String(call, "name"),
-				Version:       buildutil.String(call, "version"),
-				RepoName:      buildutil.String(call, "repo_name"),
-				DevDependency: buildutil.Bool(call, "dev_dependency"),
+				Name:                  buildutil.String(call, "name"),
+				Version:               buildutil.String(call, "version"),
+				MaxCompatibilityLevel: buildutil.Int(call, "max_compatibility_level"),
+				RepoName:              buildutil.String(call, "repo_name"),
+				DevDependency:         buildutil.Bool(call, "dev_dependency"),
 			}
 			if dep.Name != "" && dep.Version != "" {
 				info.Dependencies = append(info.Dependencies, dep)