Struct DependencyResolver 

pub struct DependencyResolver { /* private fields */ }

Main dependency resolver with service-based architecture.

This orchestrates multiple specialized services to handle different aspects of the dependency resolution process while maintaining compatibility with existing interfaces.

Architecture

The resolver follows a modular service pattern where each complex aspect of resolution is delegated to a specialized service:

• VersionResolutionService handles Git operations and batch SHA resolution
• PatternExpansionService expands glob patterns into concrete dependencies
• Version conflict detection identifies and reports version conflicts

Resolution Process

The resolution occurs in distinct phases:

1. Collection Phase: Extract dependencies from the project manifest
2. Version Resolution Phase: Batch resolve all version constraints to commit SHAs
3. Pattern Expansion Phase: Expand glob patterns (e.g., agents/*.md) into individual resources
4. Transitive Resolution Phase (optional): Resolve dependencies declared within resources
5. Conflict Detection Phase: Detect and report version conflicts across the dependency graph

Examples

use agpm_cli::resolver::DependencyResolver;
use agpm_cli::manifest::Manifest;
use agpm_cli::cache::Cache;

// Load manifest and create cache
let manifest = Manifest::load_from_file("agpm.toml")?;
let cache = Cache::new()?;

// Create resolver and resolve dependencies
let mut resolver = DependencyResolver::new(manifest, cache).await?;
let lockfile = resolver.resolve().await?;

println!("Resolved {} dependencies", lockfile.total_resources());

Key Features

• Parallel Processing: Configurable concurrency for performance
• SHA-based Deduplication: Shared worktrees for identical commits
• Transitive Dependencies: Optional resolution of dependencies of dependencies
• Version Constraints: Support for semver-style constraints (^1.0, ~2.1)
• Pattern Support: Glob patterns for bulk dependency inclusion
• Conflict Detection: Comprehensive detection of version conflicts

Related Services

• VersionResolutionService: Git operations and SHA resolution
• PatternExpansionService: Glob pattern handling
• Service container for transitive resolution (transitive_resolver::ResolutionServices)
• Version conflict detection and reporting (conflict_detector::ConflictDetector)

Implementations

impl DependencyResolver

pub async fn new(manifest: Manifest, cache: Cache) -> Result<Self>

Create a new dependency resolver.

Arguments

• manifest - Project manifest with dependencies
• cache - Cache for Git operations and worktrees

Errors

Returns an error if source manager cannot be created

pub async fn new_with_context( manifest: Manifest, cache: Cache, operation_context: Option<Arc<OperationContext>>, ) -> Result<Self>

Create a new dependency resolver with operation context.

Arguments

• manifest - Project manifest with dependencies
• cache - Cache for Git operations and worktrees
• operation_context - Optional context for warning deduplication

Errors

Returns an error if source manager cannot be created

pub async fn new_with_global(manifest: Manifest, cache: Cache) -> Result<Self>

Create a new resolver with global configuration support.

This loads both manifest sources and global sources from ~/.agpm/config.toml.

Arguments

• manifest - Project manifest with dependencies
• cache - Cache for Git operations and worktrees

Errors

Returns an error if global configuration cannot be loaded

pub async fn new_with_global_concurrency( manifest: Manifest, cache: Cache, max_concurrency: Option<usize>, operation_context: Option<Arc<OperationContext>>, ) -> Result<Self>

Creates a new dependency resolver with global config and custom concurrency limit.

Arguments

• manifest - Project manifest with dependencies
• cache - Cache for Git operations and worktrees
• max_concurrency - Optional concurrency limit for parallel operations
• operation_context - Optional context for warning deduplication

Errors

Returns an error if global configuration cannot be loaded

pub async fn with_cache(manifest: Manifest, cache: Cache) -> Result<Self>

Creates a new dependency resolver with custom cache directory.

Arguments

• cache - Cache for Git operations and worktrees

Errors

Returns an error if source manager cannot be created

pub async fn new_with_global_context( manifest: Manifest, cache: Cache, operation_context: Option<Arc<OperationContext>>, ) -> Result<Self>

Create a new resolver with global configuration and operation context.

Arguments

• manifest - Project manifest with dependencies
• cache - Cache for Git operations and worktrees
• operation_context - Optional context for warning deduplication

Errors

Returns an error if global configuration cannot be loaded

pub fn core(&self) -> &ResolutionCore

Get a reference to the resolution core.

pub async fn resolve(&mut self) -> Result<LockFile>

Resolve all dependencies and generate a complete lockfile.

Performs dependency resolution with automatic conflict detection and backtracking to find compatible versions when conflicts occur.

Errors

Returns an error if any step of resolution fails

pub async fn resolve_with_options( &mut self, enable_transitive: bool, progress: Option<Arc<MultiPhaseProgress>>, ) -> Result<LockFile>

Resolve dependencies with transitive resolution option.

Arguments

• enable_transitive - Whether to resolve transitive dependencies

Errors

Returns an error if resolution fails

pub async fn pre_sync_sources( &mut self, deps: &[(String, ResourceDependency)], progress: Option<Arc<MultiPhaseProgress>>, ) -> Result<()>

Pre-sync sources for the given dependencies.

This performs Git operations to ensure all required sources are available before the main resolution process begins.

Arguments

• deps - List of (name, dependency) pairs to sync sources for

Errors

Returns an error if source synchronization fails

pub async fn update( &mut self, existing: &LockFile, deps_to_update: Option<Vec<String>>, progress: Option<Arc<MultiPhaseProgress>>, ) -> Result<LockFile>

Update dependencies with existing lockfile and specific dependencies to update.

Arguments

• existing - Existing lockfile to update
• deps_to_update - Optional specific dependency names to update (None = all)
• progress - Optional multi-phase progress tracker for UI updates

Current Implementation (MVP)

Currently performs full resolution regardless of deps_to_update value. This is correct but not optimized - all dependencies are re-resolved even when only specific ones are requested.

Future Enhancement

Full incremental update would:

1. Match deps_to_update names to lockfile entries
2. Keep unchanged dependencies at their locked versions
3. Re-resolve only specified dependencies to latest matching versions
4. Re-extract transitive dependencies for updated resources
5. Merge updated entries with unchanged entries from existing lockfile
6. Detect and resolve any new conflicts

This requires significant changes to the resolution pipeline to support “pinned” versions alongside “latest” resolution.

Errors

Returns an error if update process fails

pub async fn get_available_versions( &self, repo_path: &Path, ) -> Result<Vec<String>>

Get available versions for a repository.

Arguments

• repo_path - Path to the Git repository

Returns

List of available version strings (tags and branches)

pub async fn verify(&self, _lockfile: &LockFile) -> Result<()>

Verify that existing lockfile is still valid.

Arguments

• _lockfile - Existing lockfile to verify

Errors

Returns an error if verification fails

pub fn operation_context(&self) -> Option<&Arc<OperationContext>>

Get current operation context if available.

pub fn set_operation_context(&mut self, context: Arc<OperationContext>)

Set the operation context for warning deduplication.

Arguments

• context - The operation context to use