Combine the first two commits of a Git repository?

You tried:

git rebase -i A 

It is possible to start like that if you continue with edit rather than squash:

edit e97a17b B pick asd314f C 

then run

git reset --soft HEAD^ git commit --amend git rebase --continue 

Done.

A was the initial commit, but now you want B to be the initial commit. git commits are whole trees, not diffs even if they are normally described and viewed in terms of the diff that they introduce.

This recipe works even if there are multiple commits between A and B, and B and C.

# Go back to the last commit that we want # to form the initial commit (detach HEAD) git checkout <sha1_for_B> # reset the branch pointer to the initial commit, # but leaving the index and working tree intact. git reset --soft <sha1_for_A> # amend the initial tree using the tree from 'B' git commit --amend # temporarily tag this new initial commit # (or you could remember the new commit sha1 manually) git tag tmp # go back to the original branch (assume master for this example) git checkout master # Replay all the commits after B onto the new initial commit git rebase --onto tmp <sha1_for_B> # remove the temporary tag git tag -d tmp 

In the case that you have hundreds or thousands of commits, using kostmo's answer of

git rebase -i --root 

can be impractical and slow, just due to the large number of commits that the rebase script has to process twice, once to generate the interactive rebase editor list (where you select what action to take for each commit), and once to actually execute the re-application of commits.

Here is an alternative solution that will avoid the time cost of generating the interactive rebase editor list by not using an interactive rebase in the first place. In this way, it's similar to Charles Bailey's solution. You simply create an orphan branch from the second commit, and then rebase all the descendant commits on top of it:

git checkout --orphan orphan <second-commit-sha> git commit -m "Enter a commit message for the new root commit" git rebase --onto orphan <second-commit-sha> master 

Documentation

• git-checkout(1) Manual Page
• git-rebase(1) Manual Page

In the case of interactive rebase, you have to do it before A so that the list will be:

pick A pick B pick C 

to become:

pick A squash B pick C 

If A is the initial commit, you have to have a different initial commit before A. Git thinks in differences, it will work on the difference between (A and B) and (B and C). Hence the squash not working in your example.

In a related question, I managed to come up with a different approach to the need of squashing against the first commit, which is, well, to make it the second one.

If you're interested: git: how to insert a commit as the first, shifting all the others?

Git command for squad: git rebase -i HEAD~[number of commits]

Lets say you have below git commit history:

pick 5152061 feat: Added support for saving image. (A)
pick 39c5a04 Fix: bug fixes. (B)
pick 839c6b3 fix: conflict resolved. (C)

Now you want to squash A and B to AB, perform below steps:

pick 5152061 feat: Added support for saving image. (A)
s 39c5a04 Fix: bug fixes. (B)
pick 839c6b3 fix: conflict resolved. (C)

Note: for squashing commit we can use squash or s. The end result will be:
pick 5152061 feat: Added support for saving image. (AB)
pick 839c6b3 fix: conflict resolved. (C)

You have to perform a bit of command-line magic.

git checkout -b a A git checkout B <files> git commit --amend git checkout master git rebase a 

That should leave you with a branch that has AB and C as commits.

I'm also wondering what if the structure is like

X-Y------Z \-A-B-C/ 

and I want the final structure to be

X-Y-----Z \-AB-C/ 

In this case how do I combine A and B?