cargo-rail: fixing the weird 'transitive' issue in virtual workspaces; fixing the version bump on 'x.y' versioning layouts.

Author: loadingalias

.gitignore

@@ -22,10 +22,10 @@ AGENTS.md
 
 # Documentation
 docs/*
-commands.md
-config.md
+final_testing.md
 rules.md
 
+
 # Cargo-Rail (Testing)
 *rail.toml
 .config/rail.toml.example

src/cargo/manifest_ops.rs

@@ -184,6 +184,35 @@ pub fn build_transitive_entry(features: &[String]) -> Item {
   Item::Value(value)
 }
 
+/// Build a versioned dependency entry for [workspace.dependencies]
+///
+/// Used when adding transitive dependencies to workspace.dependencies.
+/// Creates entries like: `dep = { version = "1.0", features = ["foo"] }`
+///
+/// # Arguments
+///
+/// * `version` - The semver version to use
+/// * `features` - Features to enable
+pub fn build_versioned_dep_entry(version: &semver::Version, features: &[String]) -> Item {
+  // Simple case: just version, no features
+  if features.is_empty() {
+    let mut value = Value::from(format!("^{}", version));
+    value.decor_mut().set_suffix(" #unified");
+    return Item::Value(value);
+  }
+
+  // Complex case: version + features
+  let mut table = InlineTable::new();
+  table.insert("version", Value::from(format!("^{}", version)));
+  table.insert("features", build_feature_array(features));
+
+  // Add #unified comment marker
+  let mut value = Value::InlineTable(table);
+  value.decor_mut().set_suffix(" #unified");
+
+  Item::Value(value)
+}
+
 // ============================================================================
 // SECTION 2: Workspace Reference Detection
 // ============================================================================

src/cargo/manifest_writer.rs

@@ -4,7 +4,7 @@
 
 use crate::cargo::manifest_analyzer::DepKind;
 use crate::cargo::manifest_ops;
-use crate::cargo::unify_analyzer::UnifiedDep;
+use crate::cargo::unify_analyzer::{TransitivePin, UnifiedDep};
 use crate::error::{RailResult, ResultExt};
 use crate::toml::format::TomlFormatter;
 use std::path::Path;
@@ -137,22 +137,22 @@ impl ManifestWriter {
   }
 
   /// Add transitive dependencies for pinning (workspace-hack replacement)
-  pub fn add_transitive_pins(
-    &self,
-    host_toml_path: &Path,
-    transitives: &[(String, Vec<String>)], // (dep_name, features)
-  ) -> RailResult<()> {
+  ///
+  /// This adds entries with `workspace = true` to the host's dev-dependencies.
+  /// IMPORTANT: The caller must ensure these deps are already in [workspace.dependencies]
+  /// before calling this function. Use `write_transitive_workspace_deps` first.
+  pub fn add_transitive_pins(&self, host_toml_path: &Path, transitives: &[TransitivePin]) -> RailResult<()> {
     // Read host Cargo.toml (usually workspace root)
     let mut doc = manifest_ops::read_toml_file(host_toml_path)?;
 
     // Ensure [dev-dependencies] exists
     let dev_deps =
       manifest_ops::get_or_create_table(&mut doc, "dev-dependencies").context("Failed to create [dev-dependencies]")?;
 
-    // Add each transitive as a dev dependency
-    for (dep_name, features) in transitives {
-      let entry = manifest_ops::build_transitive_entry(features);
-      manifest_ops::insert_dependency(dev_deps, dep_name, entry).context("Failed to insert transitive dependency")?;
+    // Add each transitive as a dev dependency with workspace = true
+    for pin in transitives {
+      let entry = manifest_ops::build_transitive_entry(&pin.features);
+      manifest_ops::insert_dependency(dev_deps, &pin.name, entry).context("Failed to insert transitive dependency")?;
     }
 
     // Format and write
@@ -162,6 +162,37 @@ impl ManifestWriter {
     Ok(())
   }
 
+  /// Write transitive dependencies to [workspace.dependencies]
+  ///
+  /// This must be called BEFORE `add_transitive_pins` so that the deps exist
+  /// in workspace.dependencies when referenced with `workspace = true`.
+  pub fn write_transitive_workspace_deps(
+    &self,
+    workspace_toml_path: &Path,
+    transitives: &[TransitivePin],
+  ) -> RailResult<()> {
+    // Read workspace Cargo.toml
+    let mut doc = manifest_ops::read_toml_file(workspace_toml_path)?;
+
+    // Ensure [workspace.dependencies] exists
+    manifest_ops::ensure_section(&mut doc, "workspace").context("Failed to create [workspace] section")?;
+    let deps_table = manifest_ops::get_or_create_table(&mut doc, "workspace.dependencies")
+      .context("Failed to create [workspace.dependencies]")?;
+
+    // Add each transitive dependency with version and features
+    for pin in transitives {
+      let entry = manifest_ops::build_versioned_dep_entry(&pin.version, &pin.features);
+      manifest_ops::insert_dependency(deps_table, &pin.name, entry)
+        .context("Failed to insert transitive to workspace.dependencies")?;
+    }
+
+    // Format and write
+    self.formatter.format_manifest(&mut doc)?;
+    manifest_ops::write_toml_file(workspace_toml_path, &doc)?;
+
+    Ok(())
+  }
+
   /// Convert DepKind to Cargo.toml section name
   fn dep_kind_to_section(&self, dep_kind: DepKind) -> &'static str {
     manifest_ops::dep_kind_to_section(dep_kind)

src/cargo/mod.rs

@@ -21,6 +21,6 @@ pub use manifest_analyzer::{DepKey, DepKind, DepUsage, ManifestAnalyzer};
 pub use manifest_writer::ManifestWriter;
 pub use multi_target_metadata::{ComputedMsrv, FragmentedTransitive, MultiTargetMetadata};
 pub use unify_analyzer::{
-  DuplicateCleanup, IssueSeverity, MemberEdit, PrunedFeature, UnificationPlan, UnifiedDep, UnifyAnalyzer, UnifyIssue,
-  UnifyReport, ValidationResult,
+  DuplicateCleanup, IssueSeverity, MemberEdit, PrunedFeature, TransitivePin, UnificationPlan, UnifiedDep,
+  UnifyAnalyzer, UnifyIssue, UnifyReport, ValidationResult,
 };

src/cargo/multi_target_metadata.rs

@@ -295,8 +295,16 @@ impl MultiTargetMetadata {
         // This dep has different features across builds = fragmented
         let all_features: HashSet<String> = features.values().flat_map(|s| s.iter().cloned()).collect();
 
+        // Get the resolved version (use highest across all targets)
+        let versions = self.all_versions(&dep_name);
+        let version = match versions.values().max() {
+          Some(v) => v.clone(),
+          None => continue, // Skip if we can't determine version
+        };
+
         transitives.push(FragmentedTransitive {
           name: dep_name.to_string(),
+          version,
           feature_sets: features,
           unified_features: all_features.into_iter().collect(),
         });
@@ -363,6 +371,8 @@ impl MultiTargetMetadata {
 pub struct FragmentedTransitive {
   /// Dependency name
   pub name: String,
+  /// Resolved version (highest across all targets)
+  pub version: Version,
   /// Features per target
   pub feature_sets: HashMap<String, HashSet<String>>,
   /// Union of all features (for pinning)

src/cargo/unify_analyzer.rs

@@ -155,6 +155,17 @@ pub enum UnusedReason {
   },
 }
 
+/// A transitive dependency to pin for workspace-hack replacement
+#[derive(Debug, Clone)]
+pub struct TransitivePin {
+  /// Dependency name
+  pub name: String,
+  /// Resolved version
+  pub version: semver::Version,
+  /// Features to enable
+  pub features: Vec<String>,
+}
+
 /// Complete unification plan
 #[derive(Debug)]
 pub struct UnificationPlan {
@@ -164,8 +175,8 @@ pub struct UnificationPlan {
   pub member_edits: HashMap<String, Vec<MemberEdit>>,
   /// Mapping from package name to manifest path (relative to workspace root)
   pub member_paths: HashMap<String, PathBuf>,
-  /// Transitive dependencies to pin (dep_name, features)
-  pub transitive_pins: Vec<(String, Vec<String>)>,
+  /// Transitive dependencies to pin (with version info)
+  pub transitive_pins: Vec<TransitivePin>,
   /// Results from validating across target platforms
   pub validation_results: Vec<ValidationResult>,
   /// Issues detected during analysis
@@ -783,7 +794,14 @@ impl UnifyAnalyzer {
       println!("Analyzing transitive dependencies...");
       let fragmented = self.metadata.find_fragmented_transitives();
 
-      fragmented.into_iter().map(|f| (f.name, f.unified_features)).collect()
+      fragmented
+        .into_iter()
+        .map(|f| TransitivePin {
+          name: f.name,
+          version: f.version,
+          features: f.unified_features,
+        })
+        .collect()
     } else {
       Vec::new()
     };

src/commands/init.rs

@@ -23,16 +23,15 @@ pub fn run_init(
   let config_path = workspace_root.join(output_path);
 
   // Check if target path already exists
-  if config_path.exists() {
+  // In --check mode, we just preview - so existence doesn't matter
+  if config_path.exists() && !check {
     if !force {
       return Err(RailError::with_help(
         format!("configuration exists: {}", config_path.display()),
-        "use --force to overwrite",
+        "use --force to overwrite, or use --check to preview what would be generated",
       ));
     }
-    if !check {
-      eprintln!("overwriting: {}", config_path.display());
-    }
+    eprintln!("overwriting: {}", config_path.display());
   } else if let Some(existing) = check_existing_config(workspace_root) {
     // A config exists elsewhere - warn but allow writing to different path
     if !check {
@@ -150,16 +149,15 @@ pub fn run_init_standalone(
   let config_path = workspace_root.join(output_path);
 
   // Check if target path already exists
-  if config_path.exists() {
+  // In --check mode, we just preview - so existence doesn't matter
+  if config_path.exists() && !check {
     if !force {
       return Err(RailError::with_help(
         format!("configuration exists: {}", config_path.display()),
-        "use --force to overwrite",
+        "use --force to overwrite, or use --check to preview what would be generated",
       ));
     }
-    if !check {
-      eprintln!("overwriting: {}", config_path.display());
-    }
+    eprintln!("overwriting: {}", config_path.display());
   } else if let Some(existing) = check_existing_config(workspace_root) {
     // A config exists elsewhere - warn but allow writing to different path
     if !check {

src/commands/unify.rs

@@ -315,6 +315,13 @@ pub fn run_unify_apply(
 
   if !plan.transitive_pins.is_empty() {
     eprintln!("pinning {} transitives...", plan.transitive_pins.len());
+
+    // STEP 1: Add transitive deps to [workspace.dependencies] first
+    // This is required before we can reference them with `workspace = true`
+    eprintln!("  adding to [workspace.dependencies]...");
+    writer.write_transitive_workspace_deps(&ctx.workspace_root().join("Cargo.toml"), &plan.transitive_pins)?;
+
+    // STEP 2: Add to host's [dev-dependencies] with workspace = true
     let transitive_host_setting = ctx.config.as_ref().map(|c| &c.unify.transitive_host);
     let is_root_host = matches!(
       transitive_host_setting,

src/release/version.rs

@@ -66,15 +66,11 @@ impl BumpType {
       }
       Self::Major => {
         let mut next = current.clone();
-        // For 0.x versions, bump minor instead (Cargo convention)
-        if current.major == 0 {
-          next.minor += 1;
-          next.patch = 0;
-        } else {
-          next.major += 1;
-          next.minor = 0;
-          next.patch = 0;
-        }
+        // Always bump major version - including 0.x -> 1.0.0
+        // Users who want semver-compatible "breaking change" on 0.x can use --bump minor
+        next.major += 1;
+        next.minor = 0;
+        next.patch = 0;
         next.pre = semver::Prerelease::EMPTY;
         next.build = semver::BuildMetadata::EMPTY;
         next
@@ -257,10 +253,10 @@ mod tests {
 
   #[test]
   fn test_bump_major_pre_1() {
-    // For 0.x versions, major bump increments minor
+    // For 0.x versions, major bump goes to 1.0.0
     let v = Version::parse("0.2.3").unwrap();
     let next = BumpType::Major.apply(&v);
-    assert_eq!(next, Version::parse("0.3.0").unwrap());
+    assert_eq!(next, Version::parse("1.0.0").unwrap());
   }
 
   #[test]

src/toml/builder.rs

@@ -170,15 +170,15 @@ impl RailConfigBuilder {
   /// Add splits template
   pub fn splits_template(&mut self) -> &mut Self {
     let content = r#"# Split/Sync: Use 'cargo rail split init <crate>' to configure individual crates
-# [[splits]]
-# name = "my-crate"
+# Per-crate configuration uses [crates.<name>] sections:
+#
+# [crates.my-crate.split]
 # remote = "[email protected]:org/my-crate.git"
 # branch = "main"
-# mode = "single"
-# publish = true
+# mode = "single"  # or "combined" for multi-crate repos
 #
-# [[splits.paths]]
-# crate = "crates/my-crate"
+# [crates.my-crate.release]
+# publish = true
 "#;
     self.sections.push(content.to_string());
     self
@@ -324,7 +324,7 @@ mod tests {
     assert!(output.contains("targets"));
     assert!(output.contains("[unify]"));
     assert!(output.contains("[release]"));
-    assert!(output.contains("# [[splits]]"));
+    assert!(output.contains("# [crates.my-crate.split]"));
   }
 
   #[test]