cargo-rail: fixing PR branch creation on split repo -> monorepo sync. TOML fmt is deeply broken across the codebase at this point

Author: loadingalias

src/sync/engine.rs

@@ -258,6 +258,26 @@ impl<'a> SyncEngine<'a> {
       remote_git.get_commits_touching_path(Path::new("."), None, &branch_ref)?
     };
 
+    // Always create a PR branch for safety when syncing from remote
+    // This prevents direct commits to protected branches (main, master, develop)
+    let pr_branch = if !new_commits.is_empty() {
+      // Create timestamped branch name
+      let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_else(|_| std::time::Duration::from_secs(0))
+        .as_secs();
+
+      // Format: cargo-rail-sync-CRATE-TIMESTAMP
+      let branch_name = format!("cargo-rail-sync-{}-{}", self.config.crate_name, timestamp);
+
+      println!("   Creating PR branch: {}", branch_name);
+      self.ctx.git.git().create_and_checkout_branch(&branch_name)?;
+
+      Some(branch_name)
+    } else {
+      None
+    };
+
     let mut conflicts = Vec::new();
 
     let synced_count = if new_commits.is_empty() {
@@ -308,7 +328,36 @@ impl<'a> SyncEngine<'a> {
     // Save mappings
     self.mapping_store.save(self.ctx.workspace_root())?;
 
-    // If we created a PR branch, push it to remote and remind user to create PR
+    // Print PR creation instructions if we created a branch with synced commits
+    if let Some(branch_name) = pr_branch
+      && synced_count > 0
+    {
+      println!(
+        "\n✅ Synced {} commit{} to branch: {}",
+        synced_count,
+        if synced_count == 1 { "" } else { "s" },
+        branch_name
+      );
+      println!("\n📋 To create a pull request:");
+      println!("   git push origin {}", branch_name);
+
+      // Try to detect GitHub URL and suggest gh CLI command
+      if let Ok(output) = std::process::Command::new("git")
+        .args(["config", "--get", "remote.origin.url"])
+        .current_dir(self.ctx.workspace_root())
+        .output()
+        && let Ok(url) = String::from_utf8(output.stdout)
+      {
+        let url = url.trim();
+        if url.contains("github.com") {
+          println!(
+            "   gh pr create --title \"Sync {} from remote\"",
+            self.config.crate_name
+          );
+        }
+      }
+      println!();
+    }
 
     Ok(SyncResult {
       commits_synced: synced_count,

tests/integration/test_sync.rs

@@ -72,7 +72,7 @@ fn test_sync_from_remote_basic() -> Result<()> {
   // Sync from remote
   run_cargo_rail(&ws.path, &["rail", "sync", "mylib", "--from-remote"])?;
 
-  // Verify change in monorepo
+  // Verify change in monorepo (on PR branch, not original branch)
   let mono_content = std::fs::read_to_string(ws.path.join("crates/mylib/src/lib.rs"))?;
   assert!(
     mono_content.contains("// Changed in split"),
@@ -87,6 +87,60 @@ fn test_sync_from_remote_basic() -> Result<()> {
   Ok(())
 }
 
+#[test]
+fn test_sync_from_remote_creates_pr_branch() -> Result<()> {
+  let (ws, split_dir) = setup_split_scenario("mylib")?;
+
+  // Get original branch name
+  let original_branch_output = git(&ws.path, &["rev-parse", "--abbrev-ref", "HEAD"])?;
+  let original_branch = String::from_utf8_lossy(&original_branch_output.stdout)
+    .trim()
+    .to_string();
+
+  // Make change in split repo
+  std::fs::write(split_dir.path().join("src/lib.rs"), "// Changed in split")?;
+  git(split_dir.path(), &["add", "."])?;
+  git(split_dir.path(), &["commit", "-m", "Test change in split"])?;
+
+  // Sync from remote - should create PR branch
+  run_cargo_rail(&ws.path, &["rail", "sync", "mylib", "--from-remote"])?;
+
+  // Verify we're on a PR branch (not the original branch)
+  let current_branch_output = git(&ws.path, &["rev-parse", "--abbrev-ref", "HEAD"])?;
+  let current_branch = String::from_utf8_lossy(&current_branch_output.stdout)
+    .trim()
+    .to_string();
+
+  assert!(
+    current_branch.starts_with("cargo-rail-sync-mylib-"),
+    "Should be on a PR branch starting with cargo-rail-sync-mylib-, but got: {}",
+    current_branch
+  );
+  assert_ne!(current_branch, original_branch, "Should not be on the original branch");
+
+  // Verify the change is on the PR branch
+  let mono_content = std::fs::read_to_string(ws.path.join("crates/mylib/src/lib.rs"))?;
+  assert!(
+    mono_content.contains("// Changed in split"),
+    "Change should be on PR branch"
+  );
+
+  // Verify commit has Rail-Origin trailer
+  let log_output = git(&ws.path, &["log", "-1", "--format=%B"])?;
+  let log = String::from_utf8_lossy(&log_output.stdout);
+  assert!(log.contains("Rail-Origin: remote@"), "Should have Rail-Origin trailer");
+
+  // Switch back to original branch and verify it's unchanged
+  git(&ws.path, &["checkout", &original_branch])?;
+  let original_content = std::fs::read_to_string(ws.path.join("crates/mylib/src/lib.rs"))?;
+  assert!(
+    !original_content.contains("// Changed in split"),
+    "Original branch should not have the change"
+  );
+
+  Ok(())
+}
+
 #[test]
 fn test_sync_roundtrip_preserves_content() -> Result<()> {
   let (ws, split_dir) = setup_split_scenario("mylib")?;
@@ -104,10 +158,10 @@ fn test_sync_roundtrip_preserves_content() -> Result<()> {
   let split_content = std::fs::read_to_string(split_dir.path().join("src/lib.rs"))?;
   assert_eq!(split_content, original, "Split should have original content");
 
-  // Sync back from split (should be no-op)
+  // Sync back from split (should be no-op, but creates PR branch)
   run_cargo_rail(&ws.path, &["rail", "sync", "mylib", "--from-remote"])?;
 
-  // Verify still matches
+  // Verify still matches (on PR branch)
   let final_content = std::fs::read_to_string(ws.path.join("crates/mylib/src/lib.rs"))?;
   assert_eq!(final_content, original, "Content should be preserved after roundtrip");