Reputation: 111716
I accidentally amended my previous commit. The commit should have been separate to keep history of the changes I made to a particular file.
Is there a way to undo that last commit? If I do something like git reset --hard HEAD^
, the first commit also is undone.
(I have not yet pushed to any remote directories)
Upvotes: 2009
Views: 749959
Reputation: 265757
Use the ref-log:
git branch fixing-things HEAD@{1}
git reset --soft fixing-things
You should then have all your previously amended changes in your working copy and can commit them to a new commit.
To see a full list of previous head commits type git reflog
.
You might find my other answer helpful if you are looking for a single command to achieve this and are not afraid of low-level plumbing commands.
Upvotes: 228
Reputation: 265757
You can use the low-level commit-tree
command and the reflog to construct a new commit with your current head commit's tree, but the original (pre-amend) commit as parent. The branch is forwarded by resetting both working tree and index:
git reset --soft "$(git commit-tree HEAD^{tree} -p HEAD@{1} -m 'Commit message of new commit')"
Why does this work? Let's have a look at some ASCII drawings:
C t:W (HEAD@{1}) original commit with tree W
B t:V
A t:U
This is where we start, but after amending the commit, we are left with:
C' t:X (branch; HEAD) accidentally amended commit with tree X
| C t:W (HEAD@{1}) original commit with tree W
|/
B t:V
A t:U
Commit C is no longer reachable from the branch, but it still exists in Git's database and is listed in the reflog as HEAD@{1}
.
What you want is to create the following new commit with the tree of the amended commit:
D t:X (branch; HEAD) separate commit with tree X
C t:W original commit with tree W
B t:V
A t:U
and git commit-tree HEAD^{tree} -p HEAD@{1}
does exactly that: it creates commit D with tree X (same tree as of amended commit C'), but sets the parent to C (the commit before being amended). git reset
is required to move the branch from the erroneous, amended commit to the correct, separate commit.
Upvotes: 1
Reputation: 475
This is how you can do it easily:
git reset --soft HEAD^
git commit -m "new commit msg"
Now push the changes and rebase this commit on top of last commit on which you had amended your changes.
This will make sure that the new commit has only amended changes.
Upvotes: 4
Reputation: 792897
What you need to do is to create a new commit with the same details as the current HEAD
commit, but with the parent as the previous version of HEAD
. git reset --soft
will move the branch pointer so that the next commit happens on top of a different commit from where the current branch head is now.
# Move the current head so that it's pointing at the old commit
# Leave the index intact for redoing the commit.
# HEAD@{1} gives you "the commit that HEAD pointed at before
# it was moved to where it currently points at". Note that this is
# different from HEAD~1, which gives you "the commit that is the
# parent node of the commit that HEAD is currently pointing to."
git reset --soft HEAD@{1}
# commit the current tree using the commit details of the previous
# HEAD commit. (Note that HEAD@{1} is pointing somewhere different from the
# previous command. It's now pointing at the erroneously amended commit.)
# The -C option takes the given commit and reuses the log message and
# authorship information.
git commit -C HEAD@{1}
Upvotes: 3548
Reputation: 3457
None of these answers with the use of HEAD@{1}
worked out for me, so here's my solution:
git reflog
d0c9f22 HEAD@{0}: commit (amend): [Feature] - ABC Commit Description
c296452 HEAD@{1}: commit: [Feature] - ABC Commit Description
git reset --soft c296452
Your staging environment will now contain all of the changes that you accidentally merged with the c296452 commit.
Upvotes: 283
Reputation: 51
Simple Solution Solution Works Given: If your HEAD commit is in sync with remote commit.
The cherry-picked commit will only contain your latest changes, not the old changes. You can now just rename this commit.
Upvotes: 4
Reputation: 5663
If you have pushed the commit to remote and then erroneously amended changes to that commit this will fix your problem. Issue a git log
to find the SHA before the commit. (this assumes remote is named origin). Now issue these command using that SHA.
git reset --soft <SHA BEFORE THE AMMEND>
#you now see all the changes in the commit and the amend undone
#save ALL the changes to the stash
git stash
git pull origin <your-branch> --ff-only
#if you issue git log you can see that you have the commit you didn't want to amend
git stash pop
#git status reveals only the changes you incorrectly amended
#now you can create your new unamended commit
Upvotes: 35
Reputation: 686
You can do below to undo your git commit —amend
git reset --soft HEAD^
git checkout files_from_old_commit_on_branch
git pull origin your_branch_name
====================================
Now your changes are as per previous. So you are done with the undo for git commit —amend
Now you can do git push origin <your_branch_name>
, to push to the branch.
Upvotes: 17
Reputation: 166813
Find your amended commits by:
git log --reflog
Note: You may add --patch
to see the body of the commits for clarity. Same as git reflog
.
then reset your HEAD to any previous commit at the point it was fine by:
git reset SHA1 --hard
Note: Replace SHA1 with your real commit hash. Also note that this command will lose any uncommitted changes, so you may stash them before. Alternatively, use --soft
instead to retain the latest changes and then commit them.
Then cherry-pick the other commit that you need on top of it:
git cherry-pick SHA1
Upvotes: 145
Reputation: 8585
Almost 9 years late to this but didn't see this variation mentioned accomplishing the same thing (it's kind of a combination of a few of these, similar to to top answer (https://stackoverflow.com/a/1459264/4642530).
Search all detached heads on branch
git reflog show origin/BRANCH_NAME --date=relative
Then find the SHA1 hash
Reset to old SHA1
git reset --hard SHA1
Then push it back up.
git push origin BRANCH_NAME
Done.
This will revert you back to the old commit entirely.
(Including the date of the prior overwritten detached commit head)
Upvotes: 8
Reputation: 507
Possibly worth noting that if you're still in your editor with the commit message, you can delete the commit message and it will abort the git commit --amend
command.
Upvotes: 30
Reputation: 659
Maybe can use git reflog
to get two commit before amend and after amend.
Then use git diff before_commit_id after_commit_id > d.diff
to get diff between before amend and after amend.
Next use git checkout before_commit_id
to back to before commit
And last use git apply d.diff
to apply the real change you did.
That solves my problem.
Upvotes: 23
Reputation: 5545
Checkout to temporary branch with last commit
git branch temp HEAD@{1}
Reset last commit
git reset temp
Now, you'll have all files your commit as well as previous commit. Check status of all the files.
git status
Reset your commit files from git stage.
git reset myfile1.js
(so on)
Reattach this commit
git commit -C HEAD@{1}
Add and commit your files to new commit.
Upvotes: 4
Reputation: 23198
You can always split a commit, From the manual
Upvotes: 26