Conflict Resolution Guide

# Resolve conflicts in the current lock file
rhema lock resolve-conflicts
 
# Resolve conflicts in a specific lock file
rhema lock resolve-conflicts --file path/to/rhema.lock
 
# Show detailed information about conflicts
rhema lock resolve-conflicts --verbose
 
# Show only conflicts that need manual resolution
rhema lock resolve-conflicts --manual-only

# Use a specific resolution strategy
rhema lock resolve-conflicts --strategy smart_selection
 
# Configure fallback strategies
rhema lock resolve-conflicts --fallback-strategies "conservative,manual_resolution"
 
# Set compatibility threshold for smart selection
rhema lock resolve-conflicts --compatibility-threshold 0.9
 
# Enable parallel resolution for better performance
rhema lock resolve-conflicts --parallel --max-threads 8
 
# Prefer stable versions
rhema lock resolve-conflicts --prefer-stable
 
# Enforce pinned versions strictly
rhema lock resolve-conflicts --strict-pinning

# Generate a detailed report
rhema lock resolve-conflicts --report-file conflict-report.json --format json
 
# Show performance metrics
rhema lock resolve-conflicts --show-metrics
 
# Apply resolved changes to lock file
rhema lock resolve-conflicts --apply
 
# Dry run (don't apply changes)
rhema lock resolve-conflicts --apply=false

rhema lock resolve-conflicts --strategy latest_compatible

rhema lock resolve-conflicts --strategy pinned_version

rhema lock resolve-conflicts --strategy smart_selection --compatibility-threshold 0.8

rhema lock resolve-conflicts --strategy conservative

rhema lock resolve-conflicts --strategy aggressive

rhema lock resolve-conflicts --strategy manual_resolution --allow-prompts

rhema lock resolve-conflicts --strategy automatic_detection

rhema lock resolve-conflicts --strategy history_tracking

rhema lock resolve-conflicts --strategy hybrid

rhema lock resolve-conflicts --strategy automatic_detection --verbose

rhema lock resolve-conflicts --apply=false --verbose

rhema lock resolve-conflicts \
  --strategy smart_selection \
  --fallback-strategies "conservative,manual_resolution"

rhema lock resolve-conflicts --show-metrics

rhema lock resolve-conflicts --track-history

# In CI pipeline
rhema lock resolve-conflicts \
  --strategy conservative \
  --apply \
  --report-file conflict-report.json \
  --format json

# Check for conflicts without resolving
rhema lock resolve-conflicts \
  --strategy automatic_detection \
  --report-file conflicts.json \
  --format json

# Focus on security vulnerabilities
rhema lock resolve-conflicts \
  --strategy conservative \
  --prefer-stable \
  --strict-pinning

rhema lock resolve-conflicts --timeout 600 --parallel --max-threads 8

rhema lock resolve-conflicts --strategy manual_resolution --manual-only

rhema lock resolve-conflicts --strategy conservative --prefer-stable

rhema lock resolve-conflicts --strategy manual_resolution --verbose

rhema lock resolve-conflicts --verbose --show-metrics

rhema lock resolve-conflicts \
  --report-file debug-report.json \
  --format json \
  --verbose \
  --show-metrics

use rhema::lock::{
    ConflictResolver, ConflictResolutionConfig, ConflictResolutionStrategy,
    DependencySpec, LockSystem
};
 
// Create configuration
let config = ConflictResolutionConfig {
    primary_strategy: ConflictResolutionStrategy::SmartSelection,
    fallback_strategies: vec![
        ConflictResolutionStrategy::Conservative,
        ConflictResolutionStrategy::ManualResolution,
    ],
    compatibility_threshold: 0.8,
    prefer_stable: true,
    track_history: true,
    ..Default::default()
};
 
// Resolve conflicts
let dependencies = vec![/* your dependencies */];
let repo_path = PathBuf::from("/path/to/repo");
 
let result = LockSystem::resolve_conflicts(&dependencies, &repo_path, Some(config))?;
 
if result.successful {
    println!("Resolved {} conflicts", result.stats.auto_resolved);
} else {
    for warning in &result.warnings {
        println!("Warning: {}", warning);
    }
}

use rhema::lock::ConflictResolver;
 
let mut resolver = ConflictResolver::with_config(config);
let result = resolver.resolve_conflicts(&dependencies, &repo_path)?;
 
// Access detailed information
println!("Total conflicts: {}", result.stats.total_conflicts);
println!("Auto-resolved: {}", result.stats.auto_resolved);
println!("Manual resolution required: {}", result.stats.manual_resolution_required);
 
// Get performance metrics
let metrics = &result.performance_metrics;
println!("Total time: {}ms", metrics.total_time_ms);
println!("Memory usage: {} bytes", metrics.memory_usage_bytes);

# Simple conflict resolution
rhema lock resolve-conflicts --apply

# Production-ready conflict resolution
rhema lock resolve-conflicts \
  --strategy conservative \
  --prefer-stable \
  --strict-pinning \
  --apply \
  --report-file production-resolution.json

# Development environment with latest features
rhema lock resolve-conflicts \
  --strategy aggressive \
  --parallel \
  --max-threads 8 \
  --apply

# Detailed conflict analysis
rhema lock resolve-conflicts \
  --strategy automatic_detection \
  --verbose \
  --manual-only \
  --report-file conflict-analysis.json \
  --format json \
  --show-metrics

# Automated resolution in CI
rhema lock resolve-conflicts \
  --strategy smart_selection \
  --compatibility-threshold 0.9 \
  --apply \
  --report-file ci-resolution.json \
  --format json