How to revert initial git commit?

I commit to a git repository for the first time; I then regret the commit and want to revert it. I try

# git reset --hard HEAD~1

I get this message:

fatal: ambiguous argument 'HEAD~1': unknown revision or path not in the working tree.

This commit is the first commit of the 开发者_运维知识库repository. Any idea how to undo git's initial commit?

You just need to delete the branch you are on. You can't use git branch -D as this has a safety check against doing this. You can use update-ref to do this.

git update-ref -d HEAD

Do not use rm -rf .git or anything like this as this will completely wipe your entire repository including all other branches as well as the branch that you are trying to reset.

You can delete the HEAD and restore your repository to a new state, where you can create a new initial commit:

git update-ref -d HEAD

After you create a new commit, if you have already pushed to remote, you will need to force it to the remote in order to overwrite the previous initial commit:

git push --force origin

This question was linked from this blog post and an alternative solution was proposed for the newer versions of Git:

git branch -m master old_master
git checkout --orphan master
git branch -D old_master

This solution assumes that:

1. You have only one commit on your master branch
2. There is no branch called old_master so I'm free to use that name

It will rename the existing branch to old_master and create a new, orphaned, branch master (like it is created for new repositories) after which you can freely delete old_master... or not. Up to you.

Note: Moving or copying a git branch preserves its reflog (see this code) while deleting and then creating a new branch destroys it. Since you want to get back to the original state with no history you probably want to delete the branch, but others may want to consider this small note.

Under the conditions stipulated in the question:

• The commit is the first commit in the repository.
• Which means there have been very few commands executed:
  • a git init,
  • presumably some git add operations,
  • and a git commit,
  • and that's all!

If those preconditions are met, then the simplest way to undo the initial commit would be:

rm -fr .git

from the directory where you did git init. You can then redo the git init to recreate the Git repository, and redo the additions with whatever changes are sensible that you regretted not making the first time, and redo the initial commit.

DANGER! This removes the Git repository directory.

It removes the Git repository directory permanently and irrecoverably, unless you've got backups somewhere. Under the preconditions, you've nothing you want to keep in the repository, so you're not losing anything. All the files you added are still available in the working directories, assuming you have not modified them yet and have not deleted them, etc. However, doing this is safe only if you have nothing else in your repository at all. Under the circumstances described in the question 'commit repository first time — then regret it', it is safe. Very often, though, it is not safe.

It's also safe to do this to remove an unwanted cloned repository; it does no damage to the repository that it was cloned from. It throws away anything you've done in your copy, but doesn't affect the original repository otherwise.

Be careful, but it is safe and effective when the preconditions are met.

If you've done other things with your repository that you want preserved, then this is not the appropriate technique — your repository no longer meets the preconditions for this to be appropriate.

I will throw in what worked for me in the end. I needed to remove the initial commit on a repository as quarantined data had been misplaced, the commit had already been pushed.

Make sure you are are currently on the right branch.

git checkout master

git update-ref -d HEAD

git commit -m "Initial commit

git push -u origin master

This was able to resolve the problem.

Important

This was on an internal repository which was not publicly accessible, if your repository was publicly accessible please assume anything you need to revert has already been pulled down by someone else.

One option is to delete the repository and create a new one:

rm -rf .git
git init

To revert the initial commit, use the command below.

git update-ref -d HEAD

Once done, the uncommitted files are now in the staging area. You can confirm this staging status by the git status command and you'll get a result similar to the one in the screenshot linked below.

My uncommitted files in the staging area are in yellow color

Git suggests the syntax of the command to unstage the files in question (see the image above). In short use the command below:

git rm --cached . -r

The dot(.) in the command represents the current location/dir while the flag -r unstages the files recursively without prompting confirmation for each file.

You can now perform a quick git status to confirm that the the staging area is now empty.

If you had already pushed your files to a remote repo, the next step is pushing these changes to the remote repo to restore parity between the two (local & remote).

However, before pushing, create a .gitignore file and populate it with the unnecessary files. Read how to create a .gitignore file here.

At this juncture, the next best logical solution is pushing the changes to remote either with git push or git push -f (However, always remember force pushing is dangerous - read here.).

However, both of these push commands could return an error, that may require one to pull and resolve merge conflicts. So in my bid to avoid this trouble, you might just have to delete the entire remote repo (On GitHub with these instructions), then recreate it with the same name.

In addition:

• Delete the local git repo using the rm -rf .git,
• re-initialize it with git init,
• add all the current files to the staging area with git add -A,
• commit them with git commit -m "<commit message>",
• add the remote origin URL with git remote add origin <repo url>,
• and finally, push the local files once more with git push -u origin main.

PS:

There are many reasons to revert the first commit. However, I think one of the most common reasons that equally affected me is forgetting to add a .gitignore file that excludes unnecessary files from a commit. In my case, this mistake meant that I unintentionally pushed node_modules directory to the remote repository.

After further research, I found a technical article explaining a simpler method of Ignoring a Previously Committed File, that does away with the need to undergo the tedious process of uncommitting and having to delete the remote repo.

I wonder why "amend" is not suggest and have been crossed out by @damkrat, as amend appears to me as just the right way to resolve the most efficiently the underlying problem of fixing the wrong commit since there is no purpose of having no initial commit. As some stressed out you should only modify "public" branch like master if no one has clone your repo...

git add <your different stuff>
git commit --amend --author="author name <author.name@email.com>"-m "new message"

For me:

git update-ref -d HEAD
git rm --cached . -r

First line was as suggested by CB Bailey (not sure why the second line was necessary, but git didn't uncommit the files until I did that - I could tell by running git status before and after the second line above)

git reset --hard make changes, then do

git add -A
git commit --amend --no-edit 

git add -A
git commit --amend -m "commit_message"

git push origin master --force

--force will rewrite that commit you've reseted to in the first step.

Don't do this, because you're about to go against the whole idea of VCS systems and git in particular. The only good method is to create new and delete unneeded branch. See git help branch for info.

Technically, to revert the initial commit, you'd do:

git revert HEAD

But since that records a new commit that reverses the effects of the last commit, you might as well just make a new commit yourself that fixes the issues introduced by your initial commit. That way, you'd keep your initial commit (Ie, you'd keep your history unchanged.) which you might want to do (especially if, eg, you've already pushed to a shared repository). Otherwise, you might prefer to just start over. Ie, delete the repository and create a new one.