cargo-rail: added changelog via winnow instead of 'git-cliff-core' and refactored split/sync for the ExecutionEngine. working on release workflow

Author: loadingalias

Cargo.lock

@@ -34,6 +34,9 @@ serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 semver = "1.0.27"
 
+# Parsing for conventional commits (zero-copy, deterministic)
+winnow = "0.7.13"
+
 # Cryptographic hashing for plan IDs
 sha2 = "0.10.9"
 

Cargo.toml

@@ -5,7 +5,9 @@
 //! 2. Changelogs per-thing
 //! 3. Every release has name + version + last_sha
 
+use crate::core::config::ReleaseConfig;
 use crate::core::error::{RailError, RailResult};
+use crate::quality::changelog::{Changelog, ChangelogFormat, ConventionalCommit};
 use crate::release::{ReleasePlan, ReleaseTracker, VersionBump};
 use std::env;
 
@@ -126,15 +128,21 @@ pub fn run_release_apply(
   update_crate_version(&workspace_root, &release.crate_path, &plan.proposed_version.to_string())?;
   println!("   Updated Cargo.toml version");
 
-  // 2. Get current HEAD SHA
+  // 2. Generate and update changelog (if configured)
+  if let Some(changelog_path) = &release.changelog {
+    generate_changelog(&workspace_root, &release, &plan, changelog_path)?;
+    println!("   Updated {}", changelog_path.display());
+  }
+
+  // 3. Get current HEAD SHA
   let head_sha = get_head_sha(&workspace_root)?;
 
-  // 3. Update rail.toml metadata
+  // 4. Update rail.toml metadata
   tracker.update_release(&name, &plan.proposed_version.to_string(), &head_sha)?;
   tracker.save()?;
   println!("   Updated rail.toml metadata");
 
-  // 4. Create git tag
+  // 5. Create git tag
   create_git_tag(&workspace_root, &name, &plan.proposed_version.to_string())?;
   println!("   Created tag: {}-v{}", name, plan.proposed_version);
 
@@ -215,6 +223,63 @@ fn create_git_tag(workspace_root: &std::path::Path, name: &str, version: &str) -
   Ok(())
 }
 
+/// Generate and update changelog
+fn generate_changelog(
+  workspace_root: &std::path::Path,
+  release: &ReleaseConfig,
+  plan: &ReleasePlan,
+  changelog_path: &std::path::Path,
+) -> RailResult<()> {
+  // Create changelog from commits
+  let current_date = chrono::Utc::now().format("%Y-%m-%d").to_string();
+  let mut changelog = Changelog::new(plan.proposed_version.to_string(), current_date);
+
+  // Parse commits and add to changelog
+  for commit in &plan.commits {
+    if let Some(parsed) = ConventionalCommit::parse(&commit.message) {
+      changelog.add_commit(parsed, commit.sha.clone());
+    }
+  }
+
+  // Generate markdown
+  let changelog_entry = changelog
+    .render(ChangelogFormat::Markdown)
+    .map_err(RailError::message)?;
+
+  // Read existing changelog or create new
+  let changelog_abs_path = workspace_root.join(changelog_path);
+  let existing_content = if changelog_abs_path.exists() {
+    std::fs::read_to_string(&changelog_abs_path)
+      .map_err(|e| RailError::message(format!("Failed to read changelog: {}", e)))?
+  } else {
+    // Create header for new changelog
+    format!(
+      "# Changelog\n\nAll notable changes to {} will be documented in this file.\n\n",
+      release.name
+    )
+  };
+
+  // Prepend new entry to existing content
+  let new_content = if existing_content.contains("# Changelog") {
+    // Find where to insert (after header)
+    if let Some(header_end) = existing_content.find("\n\n") {
+      let (header, rest) = existing_content.split_at(header_end + 2);
+      format!("{}{}{}", header, changelog_entry, rest)
+    } else {
+      format!("{}\n\n{}", existing_content, changelog_entry)
+    }
+  } else {
+    // No header, just prepend
+    format!("{}{}", changelog_entry, existing_content)
+  };
+
+  // Write updated changelog
+  std::fs::write(&changelog_abs_path, new_content)
+    .map_err(|e| RailError::message(format!("Failed to write changelog: {}", e)))?;
+
+  Ok(())
+}
+
 fn print_release_plans(plans: &[ReleasePlan]) {
   if plans.is_empty() {
     return;

src/commands/release.rs

@@ -3,9 +3,10 @@ use std::io::{self, Write};
 
 use crate::commands::doctor;
 use crate::core::config::RailConfig;
+use crate::core::context::WorkspaceContext;
 use crate::core::error::{ConfigError, RailError, RailResult};
+use crate::core::executor::PlanExecutor;
 use crate::core::plan::{Operation, OperationType, Plan};
-use crate::core::split::{SplitConfig, Splitter};
 use crate::ui::progress::{FileProgress, MultiProgress};
 use crate::utils;
 use rayon::prelude::*;
@@ -119,9 +120,6 @@ pub fn run_split(
     }
   }
 
-  // Create splitter with security config
-  let splitter = Splitter::new(config.workspace.root.clone(), config.security.clone())?;
-
   // Build plans using the unified Plan system
   let mut plans = Vec::new();
 
@@ -141,33 +139,17 @@ pub fn run_split(
       current_dir.join("..").join(remote_name)
     };
 
-    // Build unified Plan
+    // Build unified Plan with ExecuteSplit operation
     let mut plan = Plan::new(OperationType::Split, Some(split_config.name.clone()));
 
-    // Add operations
-    plan.add_operation(Operation::InitRepo {
-      path: target_repo_path.display().to_string(),
-    });
-
-    plan.add_operation(Operation::CreateCommit {
-      message: "Walking commit history for crate paths".to_string(),
-      files: crate_paths.iter().map(|p| p.display().to_string()).collect(),
-    });
-
-    plan.add_operation(Operation::Transform {
-      path: target_repo_path.join("Cargo.toml").display().to_string(),
-      transform_type: "workspace_to_concrete".to_string(),
-    });
-
-    plan.add_operation(Operation::Copy {
-      from: "auxiliary_files".to_string(),
-      to: target_repo_path.display().to_string(),
-    });
-
-    plan.add_operation(Operation::Push {
-      remote: split_config.remote.clone(),
+    // Add high-level ExecuteSplit operation
+    plan.add_operation(Operation::ExecuteSplit {
+      crate_name: split_config.name.clone(),
+      crate_paths: crate_paths.iter().map(|p| p.display().to_string()).collect(),
+      mode: format!("{:?}", split_config.mode),
+      target_repo_path: target_repo_path.display().to_string(),
       branch: split_config.branch.clone(),
-      force: false,
+      remote_url: Some(split_config.remote.clone()),
     });
 
     // Add metadata
@@ -233,6 +215,10 @@ pub fn run_split(
     println!("\n🚀 APPLY MODE - Executing split operations\n");
   }
 
+  // Build workspace context for execution
+  let workspace_context = WorkspaceContext::build(&current_dir)?;
+  let executor = PlanExecutor::new(&workspace_context);
+
   let plan_count = plans.len();
 
   // Use parallel processing for multiple crates
@@ -245,22 +231,15 @@ pub fn run_split(
       .map(|(split_config, _, _, _)| multi_progress.add_bar(1, format!("Splitting {}", split_config.name)))
       .collect();
 
+    // For parallel execution, we need to build contexts per-thread
     let results: Vec<RailResult<()>> = plans
       .into_par_iter()
       .enumerate()
-      .map(|(idx, (split_config, crate_paths, target_repo_path, _))| {
-        let split_cfg = SplitConfig {
-          crate_name: split_config.name.clone(),
-          crate_paths,
-          mode: split_config.mode.clone(),
-          target_repo_path,
-          branch: split_config.branch.clone(),
-          remote_url: Some(split_config.remote.clone()),
-        };
-
-        // Create a new splitter for this thread
-        let thread_splitter = Splitter::new(config.workspace.root.clone(), config.security.clone())?;
-        let result = thread_splitter.split(&split_cfg);
+      .map(|(idx, (_, _, _, plan))| {
+        // Build workspace context for this thread
+        let thread_context = WorkspaceContext::build(&current_dir)?;
+        let thread_executor = PlanExecutor::new(&thread_context);
+        let result = thread_executor.execute(&plan);
 
         multi_progress.inc(&bars[idx]);
         result
@@ -282,21 +261,12 @@ pub fn run_split(
       None
     };
 
-    for (split_config, crate_paths, target_repo_path, _) in plans {
+    for (split_config, _, _, plan) in plans {
       if crate_progress.is_none() {
         println!("🔨 Splitting crate '{}'...", split_config.name);
       }
 
-      let split_cfg = SplitConfig {
-        crate_name: split_config.name.clone(),
-        crate_paths,
-        mode: split_config.mode.clone(),
-        target_repo_path,
-        branch: split_config.branch.clone(),
-        remote_url: Some(split_config.remote.clone()),
-      };
-
-      splitter.split(&split_cfg)?;
+      executor.execute(&plan)?;
 
       if let Some(ref mut p) = crate_progress {
         p.inc();