compare HEAD with merge-base of HEAD and target branch

Author: christso

README.md

@@ -40,14 +40,28 @@ The compiled binary will be available at `target/release/repodiff.exe` (Windows)
 
 ## Usage
 
-### Compare Latest Commit with Another Branch
+### Compare Branches
 
-To compare the latest commit in the current branch with the latest common commit in another branch:
+To compare the latest commit on the current branch (`HEAD`) with the latest commit on another branch (`<target_branch>`):
 
 ```bash
-repodiff -b main -o output.txt
+# Default: Compare HEAD with <target_branch>'s HEAD
+repodiff -b <target_branch> -o output.txt
 ```
 
+This shows all changes on the current branch since it diverged from the target branch, *plus* any changes that occurred on the target branch after the divergence point.
+
+To compare the latest commit on the current branch (`HEAD`) with the *common ancestor* (merge-base) commit between the current branch and the target branch:
+
+```bash
+# Use --merge-base: Compare HEAD with the merge-base of HEAD and <target_branch>
+repodiff -b <target_branch> --merge-base -o output.txt
+# Short flag equivalent:
+repodiff -b <target_branch> -a -o output.txt 
+```
+
+This is often more useful for reviewing changes specific to the current branch, as it excludes changes made on the target branch after the branches diverged.
+
 ### Compare Two Specific Commits
 
 To compare a specific commit with an earlier commit:
@@ -65,10 +79,11 @@ repodiff -c <commit_hash> -p -o output.txt
 ```
 
 Parameters:
-* `-b`, `--branch`: Branch to compare the current branch's latest commit against (finds the common ancestor).
-* `-c`, `--commit`: The newer commit hash to include in the comparison.
+* `-b`, `--branch <target_branch>`: Specify the target branch for comparison. By default, compares the current branch's `HEAD` with the `<target_branch>`'s `HEAD`. Use with `--merge-base` to compare against the common ancestor instead.
+* `-a`, `--merge-base`: When used with `-b`, compare the current branch's `HEAD` against the common ancestor (merge-base) commit of the current branch and the `<target_branch>`, instead of the `<target_branch>`'s `HEAD`.
+* `-c`, `--commit <commit_hash>`: The newer commit hash to include in the comparison.
 * `-p`, `--previous [PREVIOUS_COMMIT_HASH]`: Compare the commit specified by `-c` with a previous commit. If `PREVIOUS_COMMIT_HASH` is provided, compare against that specific hash. If omitted, compare against the parent of the commit specified by `-c`.
-* `-o`, `--output_file`: (Optional) Path to the output file. If not provided, the diff will be written to `repodiff_output.txt` in the current directory.
+* `-o`, `--output_file <path>`: (Optional) Path to the output file. If not provided, the diff will be written to `repodiff_output.txt` in the current directory.
 * `-v`, `--version`: Display the current version of RepoDiff
 * `-h`, `--help`: Print help information
 

src/cli.rs

@@ -17,17 +17,27 @@ pub struct Args {
     #[arg(short = 'c', long = "commit")]
     pub commit: Option<String>,
 
-    /// Compare the latest commit on the current branch to the latest common commit with another branch
+    /// Compare the current branch HEAD with the target branch HEAD.
+    /// Use --merge-base to compare with the common ancestor instead.
     #[arg(short, long, conflicts_with_all = ["commit", "previous"])]
     pub branch: Option<String>,
 
+    /// Compare with the common ancestor (merge-base) of the current and target branch
+    #[arg(short = 'a', long, requires = "branch")]
+    pub merge_base: bool,
+
     /// Compare the specified commit (--commit) with a previous commit.
     /// If a hash is provided, compare with that specific hash.
     /// If no hash is provided, compare with the parent of the commit specified by --commit.
     #[arg(short = 'p', long = "previous", value_name = "PREVIOUS_COMMIT_HASH", num_args = 0..=1, requires = "commit", conflicts_with = "branch")]
     pub previous: Option<Option<String>>,
 }
 
+/// Abbreviate commit hash for cleaner output
+fn short_hash(hash: &str) -> &str {
+    &hash[..12.min(hash.len())]
+}
+
 /// Main entry point for the CLI
 pub fn run() -> Result<()> {
     let args = Args::parse();
@@ -36,55 +46,68 @@ pub fn run() -> Result<()> {
     let mut repodiff = RepoDiff::new("config.json")?;
     let git_ops = GitOperations::new();
 
-    // Determine the commit hashes based on provided arguments
-    let (commit1, commit2) = if let Some(branch) = args.branch {
+    // Validate arguments first
+    if args.branch.is_none() && args.commit.is_none() {
+        eprintln!("You must specify either a branch to compare (--branch [-a]) or a commit to compare (--commit -p).");
+        process::exit(1);
+    }
+    if args.commit.is_some() && args.previous.is_none() {
+        // This specific combination (--commit without --previous) is invalid
+         eprintln!("Missing comparison target. Use --previous (-p) to compare with a parent or specific commit when using --commit, or use --branch (-b) to compare with another branch.");
+         process::exit(1);
+    }
+
+    // Determine the commit hashes based on validated arguments
+    let (commit1, commit2): (String, String) = if let Some(branch) = args.branch {
         // Branch comparison logic
-        let commit1 = git_ops.get_latest_common_commit_with_branch(&branch)?;
-        let commit2 = git_ops.get_latest_commit()?;
-        
-        println!(
-            "Comparing latest common commit with branch '{}' ({}) and the latest commit on the current branch ({}).",
-            branch,
-            &commit1[..12.min(commit1.len())],
-            &commit2[..12.min(commit2.len())]
-        );
-        (commit1, commit2)
+        let head_commit = git_ops.get_latest_commit()?;
 
-    } else if let Some(commit_to_compare) = args.commit {
-        // Commit comparison logic (using --commit and --previous)
-        match args.previous {
-            Some(Some(prev_commit_hash)) => {
+        if args.merge_base {
+            // Compare HEAD with merge-base
+            let base_commit = git_ops.find_merge_base(&branch)?;
+            println!(
+                "Comparing merge-base with branch '{}' ({}) and current HEAD ({}).",
+                branch,
+                short_hash(&base_commit),
+                short_hash(&head_commit)
+            );
+            (base_commit, head_commit)
+        } else {
+            // Compare HEAD with target branch HEAD
+            let branch_head_commit = git_ops.get_branch_head(&branch)?;
+            println!(
+                "Comparing target branch '{}' HEAD ({}) and current HEAD ({}).",
+                branch,
+                short_hash(&branch_head_commit),
+                short_hash(&head_commit)
+            );
+            (branch_head_commit, head_commit)
+        }
+    } else {
+        // Commit comparison logic (--commit is guaranteed to be Some here, 
+        // and --previous is also guaranteed to be Some due to the check above)
+        let commit_to_compare = args.commit.unwrap(); // Safe due to initial check
+        match args.previous.unwrap() { // Safe due to initial check
+            Some(prev_commit_hash) => {
                 // -p <hash> provided: Compare commit_to_compare with prev_commit_hash
-                let commit1 = prev_commit_hash;
-                let commit2 = commit_to_compare;
                 println!(
                     "Comparing specified commit {} with previous commit {}.",
-                    &commit2[..12.min(commit2.len())],
-                    &commit1[..12.min(commit1.len())]
+                    short_hash(&commit_to_compare),
+                    short_hash(&prev_commit_hash)
                 );
-                (commit1, commit2)
+                (prev_commit_hash, commit_to_compare)
             }
-            Some(None) => {
+            None => {
                 // -p flag provided without value: Compare commit_to_compare with its parent
-                let commit2 = commit_to_compare;
-                let commit1 = git_ops.get_previous_commit(&commit2)?;
+                let parent_commit = git_ops.get_previous_commit(&commit_to_compare)?;
                 println!(
                     "Comparing specified commit {} with its parent commit {}.",
-                    &commit2[..12.min(commit2.len())],
-                    &commit1[..12.min(commit1.len())]
+                    short_hash(&commit_to_compare),
+                    short_hash(&parent_commit)
                 );
-                (commit1, commit2)
-            }
-            None => {
-                // Only -c provided, which is not enough for comparison.
-                eprintln!("Missing comparison target. Use --previous (-p) to compare with a parent or specific commit when using --commit, or use --branch (-b) to compare with another branch.");
-                process::exit(1);
+                (parent_commit, commit_to_compare)
             }
         }
-    } else {
-        // Neither --branch nor --commit specified.
-        eprintln!("You must specify either a branch to compare (--branch) or a commit to compare (--commit) along with a comparison target (--previous).");
-        process::exit(1);
     };
 
     // Set output file or default

src/utils/git_operations.rs

@@ -60,25 +60,25 @@ impl GitOperations {
         Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
     }
 
-    /// Get the latest common commit between the current branch and base branch
+    /// Find the merge base commit between the current branch (HEAD) and a target branch
     ///
     /// # Arguments
     ///
-    /// * `branch` - The name of the base branch to compare with
-    pub fn get_latest_common_commit_with_branch(&self, branch: &str) -> Result<String> {
+    /// * `branch` - The name of the target branch to find the common ancestor with
+    pub fn find_merge_base(&self, branch: &str) -> Result<String> {
         let output = Command::new("git")
             .args(["merge-base", "HEAD", branch])
             .output()
             .map_err(|e| {
                 RepoDiffError::GitError(format!(
-                    "Failed to get latest common commit with '{}': {}",
+                    "Failed to find merge base with branch '{}': {}",
                     branch, e
                 ))
             })?;
 
         if !output.status.success() {
             return Err(RepoDiffError::GitError(format!(
-                "Failed to get latest common commit with '{}': {}",
+                "Failed to find merge base with branch '{}': {}",
                 branch,
                 String::from_utf8_lossy(&output.stderr)
             )));
@@ -87,6 +87,28 @@ impl GitOperations {
         Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
     }
 
+    /// Get the latest commit hash for a specific branch
+    ///
+    /// # Arguments
+    ///
+    /// * `branch_name` - The name of the branch
+    pub fn get_branch_head(&self, branch_name: &str) -> Result<String> {
+        let output = Command::new("git")
+            .args(["rev-parse", branch_name])
+            .output()
+            .map_err(|e| RepoDiffError::GitError(format!("Failed to get HEAD for branch '{}': {}", branch_name, e)))?;
+
+        if !output.status.success() {
+            return Err(RepoDiffError::GitError(format!(
+                "Failed to get HEAD for branch '{}': {}",
+                branch_name,
+                String::from_utf8_lossy(&output.stderr)
+            )));
+        }
+
+        Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+    }
+
     /// Get the previous commit of a given commit hash
     ///
     /// # Arguments

tests/cli_integration_test.rs

@@ -0,0 +1,145 @@
+#[cfg(test)]
+mod tests {
+    use std::fs;
+    use std::path::PathBuf;
+    use std::process::{Command, Stdio};
+    use tempfile::{tempdir, TempDir};
+
+    struct TestRepo {
+        dir: TempDir,
+        main_head: String,
+        feature_head: String,
+        merge_base: String,
+    }
+
+    /// Sets up a temporary Git repository with a main and feature branch.
+    ///
+    /// Structure:
+    /// M1 -> M2 (main)
+    ///  \-> F1 -> F2 (feature)
+    ///
+    /// Returns commit hashes for main HEAD, feature HEAD, and the merge base.
+    fn setup_git_repo() -> Result<TestRepo, Box<dyn std::error::Error>> {
+        let dir = tempdir()?;
+        let repo_path = dir.path();
+
+        // Helper function to run git commands
+        let run_git = |args: &[&str]| -> Result<String, Box<dyn std::error::Error>> {
+            let output = Command::new("git")
+                .current_dir(repo_path)
+                .args(args)
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .output()?;
+            if !output.status.success() {
+                return Err(format!(
+                    "Git command failed: {:?}\nStderr: {}",
+                    args,
+                    String::from_utf8_lossy(&output.stderr)
+                )
+                .into());
+            }
+            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        };
+        
+        // Helper function to create a commit
+        let create_commit = |msg: &str, file_name: &str, content: &str| -> Result<String, Box<dyn std::error::Error>> {
+            fs::write(repo_path.join(file_name), content)?;
+            run_git(&["add", file_name])?;
+            run_git(&["commit", "-m", msg])?;
+            run_git(&["rev-parse", "HEAD"]) 
+        };
+
+        // Initialize repo and make first commit (M1)
+        run_git(&["init"])?;
+        run_git(&["config", "user.email", "test@example.com"])?;
+        run_git(&["config", "user.name", "Test User"])?;
+        let commit_m1 = create_commit("Initial commit", "file1.txt", "Content 1")?;
+        
+        // Ensure the primary branch is named 'main'
+        let current_branch = run_git(&["branch", "--show-current"])?;
+        if current_branch != "main" {
+            run_git(&["branch", "-M", &current_branch, "main"])?;
+        }
+        
+        // Create feature branch from main (M1) and make commits (F1, F2)
+        run_git(&["checkout", "-b", "feature"])?;
+        create_commit("Feature commit 1", "file2.txt", "Feature content A")?;
+        let commit_f2 = create_commit("Feature commit 2", "file1.txt", "Content 1 modified by feature")?;
+        
+        // Switch back to main and make commit (M2)
+        run_git(&["checkout", "main"])?;
+        let commit_m2 = create_commit("Main commit 2", "file3.txt", "Main content B")?;
+        
+        // Verify HEAD is now feature branch F2 for subsequent tests
+        run_git(&["checkout", "feature"])?; 
+
+        Ok(TestRepo {
+            dir,
+            main_head: commit_m2,
+            feature_head: commit_f2,
+            merge_base: commit_m1, // M1 is the merge base
+        })
+    }
+
+    fn run_repodiff(args: &[&str], cwd: &PathBuf) -> Result<String, Box<dyn std::error::Error>> {
+        let repodiff_path = env!("CARGO_BIN_EXE_repodiff");
+        let output = Command::new(repodiff_path)
+            .current_dir(cwd)
+            .args(args)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .output()?;
+
+        if !output.status.success() {
+            return Err(format!(
+                "repodiff command failed: {:?}\nStderr: {}",
+                args,
+                String::from_utf8_lossy(&output.stderr)
+            )
+            .into());
+        }
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    }
+
+    /// Abbreviate commit hash for cleaner output in assertions
+    fn short_hash(hash: &str) -> &str {
+        &hash[..12.min(hash.len())]
+    }
+    
+    #[test]
+    fn test_compare_branch_head() -> Result<(), Box<dyn std::error::Error>> {
+        let repo = setup_git_repo()?;
+        
+        let output = run_repodiff(&["-b", "main"], &repo.dir.path().to_path_buf())?;
+
+        let expected_output = format!(
+            "Comparing target branch 'main' HEAD ({}) and current HEAD ({})",
+            short_hash(&repo.main_head),
+            short_hash(&repo.feature_head)
+        );
+        
+        assert!(output.contains(&expected_output), "Output did not contain expected branch head comparison message.\nExpected: {}\nGot: {}", expected_output, output);
+        assert!(repo.dir.path().join("repodiff_output.txt").exists(), "Output file was not created.");
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_compare_merge_base() -> Result<(), Box<dyn std::error::Error>> {
+        let repo = setup_git_repo()?;
+        
+        let output = run_repodiff(&["-b", "main", "-a"], &repo.dir.path().to_path_buf())?;
+
+        let expected_output = format!(
+            "Comparing merge-base with branch 'main' ({}) and current HEAD ({})",
+            short_hash(&repo.merge_base),
+            short_hash(&repo.feature_head)
+        );
+        
+        assert!(output.contains(&expected_output), "Output did not contain expected merge-base comparison message.\nExpected: {}\nGot: {}", expected_output, output);
+        assert!(repo.dir.path().join("repodiff_output.txt").exists(), "Output file was not created.");
+
+        Ok(())
+    }
+}