How to fix several branches that have been born from each other, instead of from the base branch?

I have created a "fake" repository to test if what you propose in the question would work (TL;DR: it works )

After creating the initial branch structure, and making a clone of the repository, from the clone I see:

$ git log --oneline --graph --decorate --all
* 7f0350f (origin/feature/3, origin/HEAD, feature/3) L
* 28e2807 K
* a548450 J
* b7fce3c (origin/feature/2, feature/2) I
* fd5065e H
* fce8c80 G
* f81a522 (origin/feature/1, feature/1) F
* 2392005 E
* 873d8dc D
* 30e222b (HEAD -> develop, origin/master, origin/develop) C
* f158d8a B
* 05ccdb8 A

(You don't see much here, since the story is linear from A to L, each branch building on the previous one)

I execute the commands that you yourself propose:

$ git rebase --onto develop feature/2 feature/3
$ git rebase --onto develop feature/1 feature/2

This changes the hashes of all commits (because it creates new ones). The new structure appears like this. It's confusing and cumbersome because you can still see the remote branches with their original linear structure ( origin/feature/1, origin/feature/2, etc) along with the new branches "moved" to your site:

$ git log --oneline --graph --decorate --all
* b0c3bde (HEAD -> feature/2) I
* da75bad H
* dc3ca42 G
| * 8411979 (feature/3) L
| * 0710a82 K
| * 386bbd1 J
|/
| * 7f0350f (origin/feature/3, origin/HEAD) L
| * 28e2807 K
| * a548450 J
| * b7fce3c (origin/feature/2) I
| * fd5065e H
| * fce8c80 G
| * f81a522 (origin/feature/1, feature/1) F
| * 2392005 E
| * 873d8dc D
|/
* 30e222b (origin/master, origin/develop, develop) C
* f158d8a B
* 05ccdb8 A

Now we upload the changes to the remote. Since a pushnormal will fail (because the hashes have been changed), you have to force it:

$ git push --all --force

After this, the remote branches remain the same as the local ones, and the tree is simplified and matches what you were looking for:

$ git log --oneline --graph --decorate -all

* b0c3bde (feature/2) I
* da75bad H
* dc3ca42 G
| * 8411979 (feature/3) L
| * 0710a82 K
| * 386bbd1 J
|/
| * f81a522 (feature/1) F
| * 2392005 E
| * 873d8dc D
|/
* 30e222b (HEAD -> develop, master) C
* f158d8a B
* 05ccdb8 A

To check that the thing also works as expected, what I had done in each commit was simply create a file called a.txt, b.txt, etc (with the name of the commit). Now I can verify that if I do only the files , and , git checkout developare visible , and that if I go to , for example , in addition to the three previous ones I can see , but not .a.txtb.txtc.txtgit checkout feature/2g.txt h.txt i.txtd.txt e.txt f.txt

It's supposed to let git rebase --ontoyou rewrite history between two commits so that what's in between is removed from history. I'm not sure what you want to do by passing it three parameters.

In your case, I would think the following: If each branch is develop + a couple of changes (desired structure):

a--b--c (develop)
      |\
      | d--e--f (feature/1)
      |\
      | g--h--i (feature/2)
       \
        j--k--l (feature/3)

So we could squash (for example) eand fon dbecause, well, three commits is a lot for a simple and theoretically atomic change (as a feature of this type should be). In that case your desired structure ( squashed edition ) could be written as:

a--b--c (develop)
      |\
      | d' (feature/1)
      |\
      | g' (feature/2)
       \
        j' (feature/3)

A change like that would be harmless and of course you would have to use git push -fbecause after the rebase the hash will have changed.

Now think about the following: you accidentally ended up with the structure ( cascade structure ):

a--b--c (develop)
       \
        d--e--f (feature/1)
               \
                g--h--i (feature/2)
                       \
                        j--k--l (feature/3)

You can bring the waterfall structure to the squashed edition structure by doing

git checkout feature/3
git reset --soft develop
git commit -am "cambios feature/3"
git push -f

git checkout feature/2
git reset --soft develop
git commit -am "cambios feature/2"
git push -f

git checkout feature/1
git reset --soft develop
git commit -am "cambios feature/1"
git push -f

With that you arrive at:

a--b--c (develop)
      |\
      | d'' (feature/1)
      |\
      | g'' (feature/2)
       \
        j'' (feature/3)

If you notice, I stood on each branch, pointed the HEAD to develop, and generated a commit that contains just the difference between that branch and develop.

The hashes are different (they never repeat even if the file has the same content) but if you were to check out the file diffto manually apply it as a patch, they would be identical.

Good luck!

One option to avoid push --forceis:

1. Delete remote branches
2. Create new branches from develop (feature/2b, feature/2c...)
3. Cherry pick commits on each branch
4. Delete bad local branches
5. Rename the correct branches and push