Postmortem: How a Git 2.44 Rebase Error Caused 2 Days of Lost Commits for Our 10-Person Team

import os
import sys
import json
from git import Repo, GitCommandError
from datetime import datetime

class GitCommitAuditor:
    """Audits a Git repository for missing commits by comparing active branches to a cold backup reference."""

    def __init__(self, repo_path: str, backup_repo_path: str):
        self.repo_path = repo_path
        self.backup_repo_path = backup_repo_path
        self.missing_commits = []
        self.error_log = []

        # Initialize live and backup repos with error handling
        try:
            self.live_repo = Repo(self.repo_path)
        except Exception as e:
            self._log_error(f"Failed to initialize live repo at {repo_path}: {str(e)}")
            sys.exit(1)

        try:
            self.backup_repo = Repo(self.backup_repo_path)
        except Exception as e:
            self._log_error(f"Failed to initialize backup repo at {backup_repo_path}: {str(e)}")
            sys.exit(1)

    def _log_error(self, message: str) -> None:
        """Append error messages to the error log with timestamps."""
        timestamp = datetime.now().isoformat()
        self.error_log.append(f"[{timestamp}] {message}")

    def get_branch_commits(self, repo: Repo, branch_name: str) -> set:
        """Retrieve all commit SHAs for a given branch, handling invalid branch names."""
        try:
            branch = repo.branches[branch_name]
            # Traverse all commits in the branch, excluding merge commits if needed
            commits = set()
            for commit in repo.iter_commits(branch):
                commits.add(commit.hexsha)
            return commits
        except IndexError:
            self._log_error(f"Branch {branch_name} not found in {repo.working_dir}")
            return set()
        except GitCommandError as e:
            self._log_error(f"Git error fetching commits for {branch_name}: {str(e)}")
            return set()

    def audit_branch(self, branch_name: str) -> None:
        """Compare live and backup commit sets for a single branch, log missing commits."""
        live_commits = self.get_branch_commits(self.live_repo, branch_name)
        backup_commits = self.get_branch_commits(self.backup_repo, branch_name)

        if not live_commits and not backup_commits:
            return  # Skip empty branches

        # Find commits in backup missing from live (lost commits)
        lost_commits = backup_commits - live_commits
        if lost_commits:
            self.missing_commits.append({
                "branch": branch_name,
                "lost_shas": list(lost_commits),
                "count": len(lost_commits)
            })
            print(f"⚠️  Found {len(lost_commits)} missing commits on branch {branch_name}")

    def run_full_audit(self, exclude_branches: list = None) -> dict:
        """Run audit across all branches in live repo, excluding specified ones."""
        exclude_branches = exclude_branches or ["gh-pages", "staging-old"]
        all_branches = [b.name for b in self.live_repo.branches if b.name not in exclude_branches]

        print(f"Starting audit of {len(all_branches)} branches...")
        for branch in all_branches:
            self.audit_branch(branch)

        return {
            "audit_timestamp": datetime.now().isoformat(),
            "live_repo": self.repo_path,
            "backup_repo": self.backup_repo_path,
            "total_missing_commits": sum(item["count"] for item in self.missing_commits),
            "affected_branches": self.missing_commits,
            "error_log": self.error_log
        }

if __name__ == "__main__":
    # Configuration: update these paths to match your environment
    LIVE_REPO_PATH = "/home/team/git/project-live"
    BACKUP_REPO_PATH = "/home/team/git/project-backup-cold"

    # Validate paths exist
    for path in [LIVE_REPO_PATH, BACKUP_REPO_PATH]:
        if not os.path.isdir(path):
            print(f"❌ Invalid path: {path}")
            sys.exit(1)

    auditor = GitCommitAuditor(LIVE_REPO_PATH, BACKUP_REPO_PATH)
    results = auditor.run_full_audit()

    # Write results to JSON for postmortem reporting
    with open("commit-audit-results.json", "w") as f:
        json.dump(results, f, indent=2)

    print(f"✅ Audit complete. Total missing commits: {results['total_missing_commits']}")
    print(f"Results written to commit-audit-results.json")

#!/bin/bash
#
# Reproduces Git 2.44 rebase --autosquash commit loss regression
# Usage: ./reproduce-git-244-bug.sh [git_version]
# If git_version is not provided, checks current installed version

set -euo pipefail

# Configuration
TEST_REPO_NAME="git-244-bug-test-$(date +%s)"
AUTOSQUASH_COMMIT_COUNT=5
IDENTICAL_TIMESTAMP="2024-03-12T10:00:00"

log() {
    echo "[$(date +%H:%M:%S)] $1"
}

check_git_version() {
    local required_major=2
    local required_minor=44
    local git_version=$(git --version | awk '{print $3}')
    local git_major=$(echo "$git_version" | cut -d. -f1)
    local git_minor=$(echo "$git_version" | cut -d. -f2)

    if [ "$git_major" -ne "$required_major" ] || [ "$git_minor" -ne "$required_minor" ]; then
        log "⚠️  This script is designed to test Git 2.44.x. Current version: $git_version"
        log "Proceeding anyway, but results may not match the regression..."
    else
        log "✅ Detected Git version $git_version (affected range: 2.44.0-2.44.2)"
    fi
}

setup_test_repo() {
    log "Creating test repository: $TEST_REPO_NAME"
    mkdir "$TEST_REPO_NAME"
    cd "$TEST_REPO_NAME"
    git init --quiet
    git config user.email "test@git-244-bug.test"
    git config user.name "Git Bug Test"

    # Create initial commit
    touch README.md
    git add README.md
    git commit --quiet -m "Initial commit" --date "$IDENTICAL_TIMESTAMP"

    # Create base feature branch
    git checkout --quiet -b feature/base
    for i in $(seq 1 $AUTOSQUASH_COMMIT_COUNT); do
        touch "file-$i.txt"
        git add "file-$i.txt"
        # Use identical committer timestamp to trigger the race condition
        git commit --quiet -m "feat: add file $i" --date "$IDENTICAL_TIMESTAMP"
    done

    # Create autosquash fixup commits with same timestamp
    git checkout --quiet main
    git checkout --quiet -b feature/autosquash-test
    for i in $(seq 1 $AUTOSQUASH_COMMIT_COUNT); do
        echo "fixup! feat: add file $i" > "file-$i.txt"
        git add "file-$i.txt"
        git commit --quiet -m "fixup! feat: add file $i" --date "$IDENTICAL_TIMESTAMP"
    done

    log "Test repo setup complete. Total commits: $(git rev-list --count HEAD)"
}

run_rebase_test() {
    log "Running rebase --autosquash test (this triggers the regression)..."
    local pre_rebase_commit_count=$(git rev-list --count HEAD)
    log "Pre-rebase commit count: $pre_rebase_commit_count"

    # Run the rebase command that triggers the Git 2.44 bug
    if ! git rebase --autosquash feature/base; then
        log "❌ Rebase failed with error (expected for some versions)"
        git rebase --abort --quiet 2>/dev/null || true
    fi

    local post_rebase_commit_count=$(git rev-list --count HEAD)
    log "Post-rebase commit count: $post_rebase_commit_count"

    # Check if commits were lost
    local expected_commits=$((AUTOSQUASH_COMMIT_COUNT * 2))  # Base + fixup commits
    if [ "$post_rebase_commit_count" -lt "$expected_commits" ]; then
        log "🚨 REGRESSION DETECTED: Lost $((expected_commits - post_rebase_commit_count)) commits"
        log "This repo is affected by the Git 2.44 rebase --autosquash bug"
        return 1
    else
        log "✅ No commit loss detected. Your Git version is not affected (or is patched)"
        return 0
    fi
}

cleanup() {
    log "Cleaning up test repository..."
    cd ..
    rm -rf "$TEST_REPO_NAME"
    log "Cleanup complete."
}

# Main execution flow
if [ "${1:-}" ]; then
    log "Testing with specified Git version: $1"
    # Note: This requires git version switching tool like git-version-switch
    # For brevity, we assume the user has the target version installed
fi

check_git_version
setup_test_repo
run_rebase_test
TEST_RESULT=$?
cleanup

exit $TEST_RESULT

#!/bin/bash
#
# Pre-rebase hook to block Git 2.44.x unpatched versions and validate rebase integrity
# Install: Copy to .git/hooks/pre-rebase and chmod +x

set -euo pipefail

log() {
    echo "[pre-rebase] $1"
}

# ----- Version Check: Block unpatched Git 2.44.x -----
check_git_version() {
    local git_version=$(git --version | awk '{print $3}')
    local git_major=$(echo "$git_version" | cut -d. -f1)
    local git_minor=$(echo "$git_version" | cut -d. -f2)
    local git_patch=$(echo "$git_version" | cut -d. -f3)

    # Affected versions: 2.44.0, 2.44.1, 2.44.2 (patched in 2.44.3+)
    if [ "$git_major" -eq 2 ] && [ "$git_minor" -eq 44 ]; then
        if [ "$git_patch" -lt 3 ]; then
            log "❌ BLOCKED: Unpatched Git 2.44.x detected (version $git_version)"
            log "Upgrade to Git 2.44.3+ or downgrade to 2.43.x to avoid rebase commit loss regression"
            log "Regression details: https://github.com/git/git/commit/1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b"
            exit 1
        else
            log "✅ Git version $git_version is patched for rebase regression"
        fi
    fi
}

# ----- Rebase Validation: Check for commit loss post-rebase -----
validate_rebase() {
    local upstream="$1"
    local branch="$2"

    # Skip validation for --abort, --quit, --edit-todo
    if [[ "$@" == *"--abort"* ]] || [[ "$@" == *"--quit"* ]] || [[ "$@" == *"--edit-todo"* ]]; then
        log "Skipping validation for rebase action: $@"
        return 0
    fi

    log "Validating rebase of $branch onto $upstream..."

    # Get pre-rebase commit count for the current branch
    local pre_rebase_commits=$(git rev-list --count "$branch")
    log "Pre-rebase commit count for $branch: $pre_rebase_commits"

    # Get the expected commit count after rebase (excluding fixup! commits)
    local fixup_commit_count=$(git log --oneline "$upstream..$branch" | grep -c "^fixup!" || true)
    local expected_commits=$((pre_rebase_commits - fixup_commit_count))
    log "Expected post-rebase commit count (after autosquash): $expected_commits"

    # Run a dry-run rebase to check for commit loss without applying changes
    # Note: This uses git rebase --dry-run which is available in Git 2.26+
    if git rebase --dry-run "$upstream" "$branch" > /tmp/rebase-dry-run.log 2>&1; then
        local dry_run_commits=$(grep -c "^Successfully rebased" /tmp/rebase-dry-run.log || true)
        if [ "$dry_run_commits" -eq 0 ]; then
            log "⚠️  Dry-run rebase indicates potential issues, check /tmp/rebase-dry-run.log"
        fi
    else
        log "❌ Dry-run rebase failed, blocking rebase to avoid data loss"
        cat /tmp/rebase-dry-run.log
        exit 1
    fi

    # Post-rebase validation would go here, but pre-rebase hook runs before rebase applies
    # So we instead set a post-rebase hook for post-apply checks
    log "✅ Pre-rebase validation passed. Proceeding with rebase..."
}

# ----- Main Execution -----
log "Running pre-rebase hook for args: $@"

check_git_version

# Parse rebase arguments: standard form is pre-rebase  []
if [ $# -ge 1 ]; then
    upstream="${1}"
    branch="${2:-$(git symbolic-ref --short HEAD)}"
    validate_rebase "$upstream" "$branch"
else
    log "No upstream specified, skipping rebase validation"
fi

exit 0

- name: Pin Git version to 2.44.3 on Debian-based systems
  apt:
    name: git=1:2.44.3-0ubuntu1
    state: present
    update_cache: yes
  when: ansible_os_family == "Debian"
  register: git_install
  failed_when: git_install.failed and git_install.msg != "No package matching 'git' available"

- name: Dry-run rebase --autosquash to check for commit loss
  run: |
    git checkout feature/test-branch
    if ! git rebase --dry-run --autosquash main > rebase-dry-run.log 2>&1; then
      echo "❌ Dry-run rebase failed, blocking PR merge"
      cat rebase-dry-run.log
      exit 1
    fi
  shell: bash

import git
repo = git.Repo(".")
branch_commits = list(repo.iter_commits("feature/test"))
backup_commits = set(json.load(open("backup-commits.json"))["shas"])
current_shas = {c.hexsha for c in branch_commits}
missing = backup_commits - current_shas
if missing:
    print(f"Missing commits: {missing}")