cargo-rail: cleaning up old code, dead commands, flags, etc

Author: loadingalias

.gitignore

@@ -23,6 +23,7 @@ AGENTS.md
 # Documentation
 docs/*
 TODO.md
+CLI_AND_CONFIG_AUDIT.md
 
 # Cargo-Rail (Testing)
 *rail.toml

README.md

@@ -64,7 +64,7 @@ cargo rail test --explain
 
 ```bash
 # Preview unification changes
-cargo rail unify --dry-run
+cargo rail unify --check
 
 # Apply unification to workspace.dependencies
 cargo rail unify
@@ -218,7 +218,7 @@ cargo rail test --nextest --watch      # Watch mode with nextest
 ### Dependency Unification
 
 ```bash
-cargo rail unify --dry-run             # Preview changes
+cargo rail unify --check             # Preview changes
 cargo rail unify                       # Apply unification
 ```
 
@@ -234,7 +234,7 @@ cargo rail status                      # Show sync status
 
 ```bash
 # Plan releases with dependency-aware ordering
-cargo rail release --all --bump minor --dry-run
+cargo rail release --all --bump minor --check
 
 # Execute: bump versions, generate changelogs, tag, publish
 cargo rail release --all --bump patch --execute

src/backup/metadata.rs

@@ -16,7 +16,7 @@ pub struct BackupMetadata {
   /// When the backup was created (ISO 8601 format)
   pub timestamp: String,
 
-  /// Command that created this backup (e.g., "cargo rail unify apply")
+  /// Command that created this backup (e.g., "cargo rail unify")
   pub command: String,
 
   /// Files that were backed up (relative to workspace root)
@@ -140,8 +140,8 @@ mod tests {
 
   #[test]
   fn test_backup_metadata_creation() {
-    let mut metadata = BackupMetadata::new("cargo rail unify apply");
-    assert_eq!(metadata.command, "cargo rail unify apply");
+    let mut metadata = BackupMetadata::new("cargo rail unify");
+    assert_eq!(metadata.command, "cargo rail unify");
     assert!(metadata.files_modified.is_empty());
     assert!(metadata.config_snapshot.is_none());
 
@@ -162,7 +162,7 @@ mod tests {
     let backup_dir = temp_dir.path();
 
     // Create and save metadata
-    let mut original = BackupMetadata::new("cargo rail unify apply");
+    let mut original = BackupMetadata::new("cargo rail unify");
     original.add_file("Cargo.toml");
     original.add_file("crates/foo/Cargo.toml");
     original = original.with_description("Test backup");

src/backup/mod.rs

@@ -19,7 +19,7 @@
 //! let manager = BackupManager::new(workspace_root);
 //!
 //! // Create backup before modifications
-//! let metadata = BackupMetadata::new("cargo rail unify apply");
+//! let metadata = BackupMetadata::new("cargo rail unify");
 //! let backup_id = manager.create_backup(&files_to_backup, metadata)?;
 //!
 //! // Restore if needed

src/cargo/manifest_analyzer.rs

@@ -418,6 +418,10 @@ impl ManifestAnalyzer {
   ///
   /// Used when mixed default-features are detected or intersection is empty.
   /// Includes ALL dep kinds (Normal, Dev, Build) per design doc requirements.
+  ///
+  /// **IMPORTANT**: Only includes features from UNCONDITIONAL usages (no target constraint).
+  /// Features from target-specific usages (e.g., `[target.'cfg(linux)'.dependencies]`)
+  /// are excluded because they may not be valid on all platforms and should stay local.
   pub fn compute_union(&self, dep: &DepKey) -> BTreeSet<String> {
     let Some(usages) = self.usage_index.get(dep) else {
       return BTreeSet::new();
@@ -428,36 +432,69 @@ impl ManifestAnalyzer {
       return BTreeSet::new();
     }
 
-    // Union all features from all usage sites
+    // Union features from UNCONDITIONAL usages only
+    // Target-specific features stay local to avoid platform incompatibilities
     let mut union = BTreeSet::new();
     for usage in usages {
-      union.extend(usage.unconditional_features.iter().cloned());
+      if usage.target.is_none() {
+        union.extend(usage.unconditional_features.iter().cloned());
+      }
     }
 
     union
   }
 
+  /// Compute features that are ONLY declared with target constraints
+  ///
+  /// These features should stay local (in member Cargo.toml) because they may
+  /// have platform-specific requirements (like cfg flags or OS restrictions).
+  /// Returns the set of features that appear only in target-constrained usages.
+  pub fn compute_target_local_features(&self, dep: &DepKey) -> BTreeSet<String> {
+    let Some(usages) = self.usage_index.get(dep) else {
+      return BTreeSet::new();
+    };
+
+    // Collect features from target-constrained usages
+    let mut target_features = BTreeSet::new();
+    for usage in usages {
+      if usage.target.is_some() {
+        target_features.extend(usage.unconditional_features.iter().cloned());
+      }
+    }
+
+    // Subtract features that also appear unconditionally
+    let unconditional = self.compute_union(dep);
+    target_features.difference(&unconditional).cloned().collect()
+  }
+
   /// Compute the intersection of features used by all packages that depend on this dependency
   ///
   /// This is the CORE of the minimal feature approach:
   /// Only features that are ALWAYS enabled go into [workspace.dependencies].
   /// Members that need more can add local features.
   /// Includes ALL dep kinds (Normal, Dev, Build) per design doc requirements.
+  ///
+  /// **IMPORTANT**: Only considers UNCONDITIONAL usages (no target constraint).
+  /// Target-specific usages are excluded because their features may have
+  /// platform-specific requirements.
   pub fn compute_intersection(&self, dep: &DepKey) -> BTreeSet<String> {
     let Some(usages) = self.usage_index.get(dep) else {
       return BTreeSet::new();
     };
 
+    // Filter to unconditional usages only
+    let unconditional_usages: Vec<_> = usages.iter().filter(|u| u.target.is_none()).collect();
+
     // Include ALL dep kinds - workspace deps serve all usage contexts
-    if usages.len() < 2 {
-      return BTreeSet::new(); // Not enough uses to unify
+    if unconditional_usages.len() < 2 {
+      return BTreeSet::new(); // Not enough unconditional uses to unify
     }
 
-    // Start with the first usage's features
-    let mut intersection = usages[0].unconditional_features.clone();
+    // Start with the first unconditional usage's features
+    let mut intersection = unconditional_usages[0].unconditional_features.clone();
 
-    // Intersect with all other usages
-    for usage in &usages[1..] {
+    // Intersect with all other unconditional usages
+    for usage in &unconditional_usages[1..] {
       intersection = intersection
         .intersection(&usage.unconditional_features)
         .cloned()
@@ -484,34 +521,44 @@ impl ManifestAnalyzer {
   /// Check if a dependency has mixed default-features settings
   ///
   /// Includes ALL dep kinds (Normal, Dev, Build) per design doc requirements.
+  ///
+  /// **IMPORTANT**: Only considers UNCONDITIONAL usages (no target constraint).
   pub fn has_mixed_defaults(&self, dep: &DepKey) -> bool {
     let Some(usages) = self.usage_index.get(dep) else {
       return false;
     };
 
+    // Filter to unconditional usages only
+    let unconditional_usages: Vec<_> = usages.iter().filter(|u| u.target.is_none()).collect();
+
     // Include ALL dep kinds - workspace deps serve all usage contexts
-    if usages.len() < 2 {
+    if unconditional_usages.len() < 2 {
       return false;
     }
 
-    // Check if all have the same default-features setting
-    let first_default = usages[0].default_features;
-    !usages.iter().all(|u| u.default_features == first_default)
+    // Check if all unconditional usages have the same default-features setting
+    let first_default = unconditional_usages[0].default_features;
+    !unconditional_usages.iter().all(|u| u.default_features == first_default)
   }
 
   /// Determine the default-features policy for a dependency
   ///
   /// Includes ALL dep kinds (Normal, Dev, Build) per design doc requirements.
+  ///
+  /// **IMPORTANT**: Only considers UNCONDITIONAL usages (no target constraint).
   pub fn default_features_policy(&self, dep: &DepKey) -> Option<bool> {
     let usages = self.usage_index.get(dep)?;
 
+    // Filter to unconditional usages only
+    let unconditional_usages: Vec<_> = usages.iter().filter(|u| u.target.is_none()).collect();
+
     // Include ALL dep kinds - workspace deps serve all usage contexts
-    if usages.is_empty() {
+    if unconditional_usages.is_empty() {
       return None;
     }
 
-    // If any usage has default-features = false, we must use false at root
-    if usages.iter().any(|u| !u.default_features) {
+    // If any unconditional usage has default-features = false, we must use false at root
+    if unconditional_usages.iter().any(|u| !u.default_features) {
       Some(false)
     } else {
       Some(true)

src/cargo/unify_analyzer.rs

@@ -430,6 +430,26 @@ impl UnifyAnalyzer {
       // Get usage sites early - needed for version checks
       let usage_sites = self.manifests.get_usage_sites(dep_key);
 
+      // === CRITICAL: Check for major version conflicts ===
+      // Different major versions should NEVER be merged - this is an anti-pattern
+      // that users must fix manually. Merging features across major versions
+      // produces invalid configurations (e.g., features that don't exist in the selected version).
+      let major_versions = find_major_version_conflicts(&usage_sites);
+      if major_versions.len() > 1 {
+        let versions_str: Vec<_> = major_versions.iter().map(|v| v.to_string()).collect();
+        issues.push(UnifyIssue {
+          dep_name: dep_key.name.clone(),
+          severity: IssueSeverity::Error,
+          message: format!(
+            "Multiple major versions detected (majors: {}) - cannot unify safely. \
+             This is an anti-pattern in Rust workspaces that causes duplicate compilation \
+             and wasted build resources. Please consolidate to a single major version.",
+            versions_str.join(", ")
+          ),
+        });
+        continue; // Skip this dependency entirely
+      }
+
       // === Issue B: Check for exact version pins ===
       let has_exact_pin = usage_sites
         .iter()
@@ -886,6 +906,32 @@ fn is_exact_pin(version: &str) -> bool {
   version.starts_with('=') && !version.starts_with(">=")
 }
 
+/// Extract major version from a declared version string
+///
+/// Returns the major version number, handling various version formats:
+/// - "1.0" -> Some(1)
+/// - "^2.3.0" -> Some(2)
+/// - ">=0.5" -> Some(0)
+fn extract_major_version(version: &str) -> Option<u32> {
+  let cleaned = strip_version_op(version);
+  let parts: Vec<&str> = cleaned.split('.').collect();
+  parts.first().and_then(|s| s.parse().ok())
+}
+
+/// Check for major version conflicts in declared versions
+///
+/// Returns the set of unique major versions found. If the set has more than
+/// one element, there's a conflict that cannot be safely unified.
+fn find_major_version_conflicts(
+  usages: &[&crate::cargo::manifest_analyzer::DepUsage],
+) -> std::collections::HashSet<u32> {
+  usages
+    .iter()
+    .filter_map(|u| u.declared_version.as_ref())
+    .filter_map(|v| extract_major_version(v))
+    .collect()
+}
+
 /// Check if two version requirements are compatible
 ///
 /// This is a heuristic check - it compares the major.minor portions
@@ -1091,6 +1137,24 @@ impl UnifyReport {
 mod tests {
   use super::*;
 
+  #[test]
+  fn test_extract_major_version() {
+    // Simple versions
+    assert_eq!(extract_major_version("1.0"), Some(1));
+    assert_eq!(extract_major_version("2.3.4"), Some(2));
+    assert_eq!(extract_major_version("0.99.3"), Some(0));
+
+    // With operators
+    assert_eq!(extract_major_version("^1.0"), Some(1));
+    assert_eq!(extract_major_version("~2.0"), Some(2));
+    assert_eq!(extract_major_version(">=3.0"), Some(3));
+    assert_eq!(extract_major_version("=4.0.0"), Some(4));
+
+    // Edge cases
+    assert_eq!(extract_major_version(""), None);
+    assert_eq!(extract_major_version("invalid"), None);
+  }
+
   #[test]
   fn test_is_exact_pin() {
     assert!(is_exact_pin("=1.0.0"));

src/commands/init.rs

@@ -88,7 +88,7 @@ pub fn run_init(
 
     println!("✅ Created {}", config_path.display());
     println!("\nNext steps:");
-    println!("  cargo rail unify --dry-run  # Preview dependency unification");
+    println!("  cargo rail unify --check  # Preview dependency unification");
   }
 
   Ok(())
@@ -232,7 +232,7 @@ pub fn run_init_standalone(
     write_config_file(&config_path, &config_toml)?;
     println!("✅ Created {}", config_path.display());
     println!("\nNext steps:");
-    println!("  cargo rail unify --dry-run  # Preview dependency unification");
+    println!("  cargo rail unify --check  # Preview dependency unification");
   }
 
   Ok(())

src/commands/split.rs

@@ -11,7 +11,7 @@ use rayon::prelude::*;
 /// Run the split command
 ///
 /// By default, executes the split operation (with confirmation prompt in interactive mode).
-/// Use --dry-run to show the plan without executing.
+/// Use --check to show the plan without executing.
 pub fn run_split(
   ctx: &WorkspaceContext,
   crate_name: Option<String>,

src/commands/sync.rs

@@ -11,7 +11,7 @@ use rayon::prelude::*;
 /// Run the sync command
 ///
 /// By default, executes the sync operation (with confirmation prompt in interactive mode).
-/// Use --dry-run to show the plan without executing.
+/// Use --check to show the plan without executing.
 #[allow(clippy::too_many_arguments)]
 pub fn run_sync(
   ctx: &WorkspaceContext,

src/commands/unify.rs

@@ -131,13 +131,13 @@ pub fn run_unify_analyze(
     let total_edits: usize = plan.member_edits.values().map(|v| v.len()).sum();
     if !plan.workspace_deps.is_empty() {
       println!(
-        "\n✅ Ready to unify {} dependencies ({} member edits). Run 'cargo rail unify apply' to apply changes.",
+        "\n✅ Ready to unify {} dependencies ({} member edits). Run 'cargo rail unify' to apply changes.",
         plan.workspace_deps.len(),
         total_edits
       );
     } else {
       println!(
-        "\n✅ Ready to convert {} members to use workspace inheritance ({} edits). Run 'cargo rail unify apply' to apply changes.",
+        "\n✅ Ready to convert {} members to use workspace inheritance ({} edits). Run 'cargo rail unify' to apply changes.",
         plan.member_edits.len(),
         total_edits
       );
@@ -227,7 +227,7 @@ pub fn run_unify_apply(
       }
     }
 
-    let metadata = BackupMetadata::new("cargo rail unify apply");
+    let metadata = BackupMetadata::new("cargo rail unify");
     let max_backups = ctx.config.as_ref().map(|c| c.unify.max_backups).unwrap_or(3);
     let backup_id = backup_manager.create_backup(&files_to_backup, metadata, max_backups)?;
     println!("   Backup created: {}", backup_id);