✨ Add changelog file update functionality

Add ability to update changelog files with generated content

This change adds a new feature to automatically update CHANGELOG.md files:
- Implement update_changelog_file function to preserve header and append new
entries
- Add strip_ansi_codes utility to clean colored output for file writing
- Update CLI with --update and --file flags for the changelog command
- Add date extraction from Git commits with get_commit_date
- Improve changelog formatting with ordered change types
- Add smart date handling for version entries

The implementation intelligently handles existing changelog files by
preserving
their structure while adding new entries in Keep a Changelog format.

Author: hyperb1iss

src/changes/changelog.rs

@@ -4,8 +4,14 @@ use super::prompt;
 use crate::common::DetailLevel;
 use crate::config::Config;
 use crate::git::GitRepo;
-use anyhow::Result;
+use crate::log_debug;
+use anyhow::{Context, Result};
+use chrono;
 use colored::Colorize;
+use regex;
+use std::fs;
+use std::io::Write;
+use std::path::Path;
 use std::sync::Arc;
 
 /// Struct responsible for generating changelogs
@@ -45,6 +51,164 @@ impl ChangelogGenerator {
 
         Ok(format_changelog_response(&changelog))
     }
+
+    /// Updates a changelog file with new content
+    ///
+    /// This function reads the existing changelog file (if it exists), preserves the header,
+    /// and prepends the new changelog content while maintaining the file structure.
+    ///
+    /// # Arguments
+    ///
+    /// * `changelog_content` - The new changelog content to prepend
+    /// * `changelog_path` - Path to the changelog file
+    /// * `git_repo` - `GitRepo` instance to use for retrieving commit dates
+    /// * `to_ref` - The "to" Git reference (commit/tag) to extract the date from
+    ///
+    /// # Returns
+    ///
+    /// A Result indicating success or an error
+    pub fn update_changelog_file(
+        changelog_content: &str,
+        changelog_path: &str,
+        git_repo: &Arc<GitRepo>,
+        to_ref: &str,
+    ) -> Result<()> {
+        let path = Path::new(changelog_path);
+        let default_header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),\nand this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n";
+
+        // Get the date from the "to" Git reference
+        let commit_date = match git_repo.get_commit_date(to_ref) {
+            Ok(date) => {
+                log_debug!("Got commit date for {}: {}", to_ref, date);
+                date
+            }
+            Err(e) => {
+                log_debug!("Failed to get commit date for {}: {}", to_ref, e);
+                chrono::Local::now().format("%Y-%m-%d").to_string()
+            }
+        };
+
+        // Strip ANSI color codes
+        let stripped_content = strip_ansi_codes(changelog_content);
+
+        // Skip the separator line if it exists (the first line with "━━━" or similar)
+        let clean_content =
+            if stripped_content.starts_with("━") || stripped_content.starts_with('-') {
+                // Find the first newline and skip everything before it
+                if let Some(pos) = stripped_content.find('\n') {
+                    stripped_content[pos + 1..].to_string()
+                } else {
+                    stripped_content
+                }
+            } else {
+                stripped_content
+            };
+
+        // Extract just the version content (skip the header)
+        let mut version_content = if clean_content.contains("## [") {
+            let parts: Vec<&str> = clean_content.split("## [").collect();
+            if parts.len() > 1 {
+                format!("## [{}", parts[1])
+            } else {
+                clean_content
+            }
+        } else {
+            clean_content
+        };
+
+        // Ensure version content has a date
+        if version_content.contains(" - \n") {
+            // Replace empty date placeholder with the commit date
+            version_content = version_content.replace(" - \n", &format!(" - {commit_date}\n"));
+            log_debug!("Replaced empty date with commit date: {}", commit_date);
+        } else if version_content.contains("] - ") && !version_content.contains("] - 20") {
+            // For cases where there's no date but a dash
+            let parts: Vec<&str> = version_content.splitn(2, "] - ").collect();
+            if parts.len() == 2 {
+                version_content = format!(
+                    "{}] - {}\n{}",
+                    parts[0],
+                    commit_date,
+                    parts[1].trim_start_matches(['\n', ' '])
+                );
+                log_debug!("Added commit date after dash: {}", commit_date);
+            }
+        } else if !version_content.contains("] - ") {
+            // If no date pattern at all, find the version line and add a date
+            let line_end = version_content.find('\n').unwrap_or(version_content.len());
+            let version_line = &version_content[..line_end];
+
+            if version_line.contains("## [") && version_line.contains(']') {
+                // Insert the date right after the closing bracket
+                let bracket_pos = version_line.rfind(']')
+                    .expect("Failed to find closing bracket in version line");
+                version_content = format!(
+                    "{} - {}{}",
+                    &version_content[..=bracket_pos],
+                    commit_date,
+                    &version_content[bracket_pos + 1..]
+                );
+                log_debug!("Added date to version line: {}", commit_date);
+            }
+        }
+
+        // Add a decorative separator after the version content
+        let separator =
+            "\n<!-- -------------------------------------------------------------- -->\n\n";
+        let version_content_with_separator = format!("{version_content}{separator}");
+
+        let updated_content = if path.exists() {
+            let existing_content = fs::read_to_string(path)
+                .with_context(|| format!("Failed to read changelog file: {changelog_path}"))?;
+
+            // Check if the file already has a Keep a Changelog header
+            if existing_content.contains("# Changelog")
+                && existing_content.contains("Keep a Changelog")
+            {
+                // Split at the first version heading
+                if existing_content.contains("## [") {
+                    let parts: Vec<&str> = existing_content.split("## [").collect();
+                    let header = parts[0];
+
+                    // Combine header with new version content and existing versions
+                    if parts.len() > 1 {
+                        let existing_versions = parts[1..].join("## [");
+                        format!(
+                            "{header}{version_content_with_separator}## [{existing_versions}"
+                        )
+                    } else {
+                        format!("{header}{version_content_with_separator}")
+                    }
+                } else {
+                    // No version sections yet, just append new content
+                    format!("{existing_content}{version_content_with_separator}")
+                }
+            } else {
+                // Existing file doesn't have proper format, overwrite with default structure
+                format!("{default_header}{version_content_with_separator}")
+            }
+        } else {
+            // File doesn't exist, create new with proper header
+            format!("{default_header}{version_content_with_separator}")
+        };
+
+        // Write the updated content back to the file
+        let mut file = fs::File::create(path)
+            .with_context(|| format!("Failed to create changelog file: {changelog_path}"))?;
+
+        file.write_all(updated_content.as_bytes())
+            .with_context(|| format!("Failed to write to changelog file: {changelog_path}"))?;
+
+        Ok(())
+    }
+}
+
+/// Strips ANSI color/style codes from a string
+fn strip_ansi_codes(s: &str) -> String {
+    // This regex matches ANSI escape codes like colors and styles
+    let re = regex::Regex::new(r"\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[m|K]")
+        .expect("Failed to compile ANSI escape code regex");
+    re.replace_all(s, "").to_string()
 }
 
 /// Formats the `ChangelogResponse` into a human-readable changelog
@@ -59,26 +223,34 @@ fn format_changelog_response(response: &ChangelogResponse) -> String {
     );
     formatted.push_str("and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n");
 
-    // Add version and release date
-    formatted.push_str(&format!(
-        "## [{}] - {}\n\n",
-        response
-            .version
-            .clone()
-            .unwrap_or_default()
-            .bright_green()
-            .bold(),
-        response.release_date.clone().unwrap_or_default().yellow()
-    ));
-
-    // Add changes grouped by type
-    for (change_type, entries) in &response.sections {
-        if !entries.is_empty() {
-            formatted.push_str(&format_change_type(change_type));
-            for entry in entries {
-                formatted.push_str(&format_change_entry(entry));
+    // Add version and release date - don't provide a date here, it will be set later
+    let version = response
+        .version
+        .clone()
+        .unwrap_or_else(|| "Unreleased".to_string());
+
+    formatted.push_str(&format!("## [{}] - \n\n", version.bright_green().bold()));
+
+    // Define the order of change types
+    let ordered_types = [
+        ChangelogType::Added,
+        ChangelogType::Changed,
+        ChangelogType::Fixed,
+        ChangelogType::Removed,
+        ChangelogType::Deprecated,
+        ChangelogType::Security,
+    ];
+
+    // Add changes in the specified order
+    for change_type in &ordered_types {
+        if let Some(entries) = response.sections.get(change_type) {
+            if !entries.is_empty() {
+                formatted.push_str(&format_change_type(change_type));
+                for entry in entries {
+                    formatted.push_str(&format_change_entry(entry));
+                }
+                formatted.push('\n');
             }
-            formatted.push('\n');
         }
     }
 

src/changes/cli.rs

@@ -22,6 +22,8 @@ use std::sync::Arc;
 /// * `from` - The starting point (commit or tag) for the changelog.
 /// * `to` - The ending point for the changelog. Defaults to "HEAD" if not provided.
 /// * `repository_url` - Optional URL of the remote repository to use.
+/// * `update_file` - Whether to update the changelog file.
+/// * `changelog_path` - Optional path to the changelog file.
 ///
 /// # Returns
 ///
@@ -31,6 +33,8 @@ pub async fn handle_changelog_command(
     from: String,
     to: Option<String>,
     repository_url: Option<String>,
+    update_file: bool,
+    changelog_path: Option<String>,
 ) -> Result<()> {
     // Load and apply configuration
     let mut config = Config::load()?;
@@ -62,6 +66,9 @@ pub async fn handle_changelog_command(
         Arc::new(GitRepo::new(&repo_path).context("Failed to create GitRepo")?)
     };
 
+    // Keep a clone of the Arc for updating the changelog later if needed
+    let git_repo_for_update = Arc::clone(&git_repo);
+
     // Set the default 'to' reference if not provided
     let to = to.unwrap_or_else(|| "HEAD".to_string());
 
@@ -79,6 +86,31 @@ pub async fn handle_changelog_command(
     println!("{}", &changelog);
     println!("{}", "━".repeat(50).bright_purple());
 
+    // Update the changelog file if requested
+    if update_file {
+        let path = changelog_path.unwrap_or_else(|| "CHANGELOG.md".to_string());
+        let update_spinner = ui::create_spinner(&format!("Updating changelog file at {path}..."));
+
+        match ChangelogGenerator::update_changelog_file(
+            &changelog,
+            &path,
+            &git_repo_for_update,
+            &to,
+        ) {
+            Ok(()) => {
+                update_spinner.finish_and_clear();
+                ui::print_success(&format!(
+                    "✨ Changelog successfully updated at {}",
+                    path.bright_green()
+                ));
+            }
+            Err(e) => {
+                update_spinner.finish_and_clear();
+                ui::print_error(&format!("Failed to update changelog file: {e}"));
+            }
+        }
+    }
+
     Ok(())
 }
 

src/cli.rs

@@ -129,6 +129,14 @@ pub enum Commands {
         /// Ending Git reference (commit hash, tag, or branch name). Defaults to HEAD if not specified.
         #[arg(long)]
         to: Option<String>,
+
+        /// Update the changelog file with the new changes
+        #[arg(long, help = "Update the changelog file with the new changes")]
+        update: bool,
+
+        /// Path to the changelog file
+        #[arg(long, help = "Path to the changelog file (defaults to CHANGELOG.md)")]
+        file: Option<String>,
     },
 
     /// Generate release notes
@@ -353,14 +361,18 @@ async fn handle_changelog(
     from: String,
     to: Option<String>,
     repository_url: Option<String>,
+    update: bool,
+    file: Option<String>,
 ) -> anyhow::Result<()> {
     log_debug!(
-        "Handling 'changelog' command with common: {:?}, from: {}, to: {:?}",
+        "Handling 'changelog' command with common: {:?}, from: {}, to: {:?}, update: {}, file: {:?}",
         common,
         from,
-        to
+        to,
+        update,
+        file
     );
-    changes::handle_changelog_command(common, from, to, repository_url).await
+    changes::handle_changelog_command(common, from, to, repository_url, update, file).await
 }
 
 /// Handle the `ReleaseNotes` command
@@ -430,8 +442,14 @@ pub async fn handle_command(
             log_debug!("Handling 'list_presets' command");
             commands::handle_list_presets_command()?;
         }
-        Commands::Changelog { common, from, to } => {
-            handle_changelog(common, from, to, repository_url).await?;
+        Commands::Changelog {
+            common,
+            from,
+            to,
+            update,
+            file,
+        } => {
+            handle_changelog(common, from, to, repository_url, update, file).await?;
         }
         Commands::ReleaseNotes { common, from, to } => {
             handle_release_notes(common, from, to, repository_url).await?;

src/git.rs

@@ -3,6 +3,7 @@ use crate::context::{ChangeType, CommitContext, ProjectMetadata, RecentCommit, S
 use crate::file_analyzers::{self, FileAnalyzer, should_exclude_file};
 use crate::log_debug;
 use anyhow::{Context, Result, anyhow};
+use chrono;
 use futures::future::join_all;
 use git2::{DiffOptions, FileMode, Repository, Status, StatusOptions, Tree};
 use std::env;
@@ -1164,6 +1165,33 @@ impl GitRepo {
 
         Ok(file_paths)
     }
+
+    /// Gets the date of a commit in YYYY-MM-DD format
+    ///
+    /// # Arguments
+    ///
+    /// * `commit_ish` - A commit-ish reference (hash, tag, branch, etc.)
+    ///
+    /// # Returns
+    ///
+    /// A Result containing the formatted date string or an error
+    pub fn get_commit_date(&self, commit_ish: &str) -> Result<String> {
+        let repo = self.open_repo()?;
+
+        // Resolve the commit-ish to an actual commit
+        let obj = repo.revparse_single(commit_ish)?;
+        let commit = obj.peel_to_commit()?;
+
+        // Get the commit time
+        let time = commit.time();
+
+        // Convert to a chrono::DateTime for easier formatting
+        let datetime = chrono::DateTime::<chrono::Utc>::from_timestamp(time.seconds(), 0)
+            .ok_or_else(|| anyhow!("Invalid timestamp"))?;
+
+        // Format as YYYY-MM-DD
+        Ok(datetime.format("%Y-%m-%d").to_string())
+    }
 }
 
 impl Drop for GitRepo {