Git Gone Wild: The Hangover - 1000 Commits Edition

11/26/2024•tutorials• by BizaNator

The Setup: What Happens in Git, Stays in Git... Or Does It?

You know that feeling when you wake up after spring break, check your phone's photo gallery, and find 1,372 nearly identical selfies from that one party? Yeah, that's basically what happened to our Git repository, except instead of embarrassing photos, we had thousands of automated commits partying in our git log like it was 1999.

Picture this: You're casually reviewing your repo one morning, coffee in hand, when suddenly you discover your automated sync script has been on a commit binge. Every single file sync created its own commit, each one shouting "Sync from Vercel: bizanator.md" like that one friend who keeps telling the same story at different volumes as the night goes on.

That's exactly what happened to us while building BrainDeadTV. Our script wasn't just doing its job - it was living its best life, creating commits like they were going out of style. It was less "continuous integration" and more "continuous intoxication" of our git history.

The Problem: The Morning After

Our Git history went from this responsible, professional-looking log:

* feat: add cool new feature
* fix: resolve edge case
* feat: implement user feedback

To looking like a frat party guest list:

* Sync from Vercel: bizanator.md
* Sync from Vercel: bizanator.md #YOLO
* Sync from Vercel: bizanator.md #PartyTime
* Sync from Vercel: bizanator.md #OneMoreWontHurt
* Sync from Vercel: bizanator.md #NoRegrets
* (... and 995 more commits that we totally regret)

Time for some Git rehab.

The Solution: Operation Git Detox

Attempt 1: The "Hair of the Dog" Approach

First, we tried the classic Git rebase command, like trying to cure a hangover with more drinks:

git rebase -i HEAD~2100

Git's response? fatal: invalid upstream 'HEAD~2100' - basically, "Nah bro, that's way too many. Maybe drink some water instead?"

Attempt 2: The "Let VS Code Handle It" Intervention

We thought VS Code might be our designated driver in this situation:

git config --global core.editor "code --wait"

But then reality hit - manually editing 2,100 lines in a rebase file? That's like trying to count how many drinks you had last night. Not happening.

The Winning Solution: The Git Reset Cleanse

Here's our tried-and-true Git detox program:

Create a backup branch (like taking a screenshot of your Snapchat story before deleting it):

git checkout -b backup-branch

Soft reset to before things got out of hand:

git reset --soft 72a1c80  # The last commit we remember clearly

Create one clean commit (the "I'll never drink again" promise):

git commit -m "Squash automated sync commits into single commit"

Force push (responsibly, like texting your ex but with a friend checking your message first):

git push origin main --force-with-lease

The Plot Twist: Merge Conflicts (AKA The Unexpected After-Party)

Just when we thought we were in the clear, merge conflicts showed up like uninvited guests. After attempting to handle them through GitHub's web interface (which felt like trying to eat soup with a fork), we went back to our trusty command line:

# The "Get Your Life Together" sequence
git checkout backup-branch
git pull origin backup-branch
git checkout main
git merge -X theirs backup-branch

But wait! The merge created a new commit - like that friend who shows up with more drinks when you're trying to leave the party. One final push to sobriety:

git checkout main
git reset --hard backup-branch
git push origin main --force-with-lease
git branch -d backup-branch
git push origin --delete backup-branch

The Happy Ending: Git Rehab Success Story

Our Git history is now clean and sober, our sync script has been to commitment counseling (it now batches its commits), and our repository is back to being a productive member of society.

Lessons Learned: Git Responsibility 101

Always have a backup branch (like a designated driver)
git reset --soft is your best friend (better than that "friend" who keeps buying shots)
--force-with-lease is safer than --force (like having a breathalyzer on your car)
When in doubt, hard reset to the last thing you remember clearly
Batch your commits (practice safe committing!)

Remember, friends don't let friends commit thousands of automated changes without batching. Happy coding! 🚀

Handy Command Reference

Here are some useful Git commands that helped us through this adventure:

# View commit history with hashes (one line per commit)
git log --oneline

# View more detailed commit history with dates and authors
git log --pretty=format:"%h - %an, %ar : %s"

# Find commits by message content (great for finding automated commits)
git log --grep="Sync from Vercel"

# View history for a specific file
git log --follow -p -- path/to/file

# Show changes in a specific commit
git show <commit-hash>

# Count total commits
git rev-list --count HEAD

Preventing Future Problems: Batch Commit Example

Here's a simple Node.js example of how to batch your automated commits instead of creating one per file:

// batchCommit.js
const { execSync } = require('child_process');
const path = require('path');

async function batchCommitChanges(changedFiles, commitMessage) {
  try {
    // Stage all changed files
    for (const file of changedFiles) {
      execSync(`git add "${file}"`, { stdio: 'inherit' });
    }

    // Create a single commit with all changes
    const timestamp = new Date().toISOString();
    const message = `${commitMessage} [${timestamp}]\n\nFiles changed:\n${changedFiles.join('\n')}`;
    execSync(`git commit -m "${message}"`, { stdio: 'inherit' });

    // Push changes
    execSync('git push origin main', { stdio: 'inherit' });

    console.log(`Successfully batch committed ${changedFiles.length} files`);
  } catch (error) {
    console.error('Error during batch commit:', error);
    throw error;
  }
}

// Example usage in your sync script:
async function syncContent() {
  const changedFiles = [];
  
  // Your existing sync logic here
  // Instead of committing each file, add them to changedFiles array
  for (const file of filesToSync) {
    try {
      await downloadAndSaveFile(file);
      changedFiles.push(file.path);
    } catch (error) {
      console.error(`Failed to sync ${file.path}:`, error);
    }
  }

  // If we have any changes, batch commit them
  if (changedFiles.length > 0) {
    await batchCommitChanges(
      changedFiles,
      `Sync: Batch update of ${changedFiles.length} files`
    );
  }
}

With this approach, instead of creating hundreds of individual commits, you'll get a single, well-documented commit that looks like this:

Sync: Batch update of 25 files [2024-11-26T12:00:00.000Z]

Files changed:
content/bizanator.md
content/chones-only.md
content/city-of-brains-01.svg
...

About the Author

This post was written by a Git survivor who learned that what happens in the command line doesn't always stay in the command line. They now run a small support group for repositories affected by automated commit addiction.