Tornar a confirmação atual a única confirmação (inicial) em um repositório Git?

Atualmente, tenho um repositório Git local, o qual envio por push para um repositório Github.

O repositório local possui ~ 10 confirmações e o repositório Github é uma duplicata sincronizada disso.

O que eu gostaria de fazer é remover TODO o histórico de versões do repositório Git local, para que o conteúdo atual do repositório apareça como o único commit (e, portanto, as versões mais antigas dos arquivos no repositório não são armazenadas).

Eu gostaria de fazer essas alterações no Github.

Eu investiguei a rebase do Git, mas isso parece ser mais adequado para remover versões específicas. Outra solução em potencial é excluir o repositório local e criar um novo - embora isso provavelmente crie muito trabalho!

ETA: Existem diretórios / arquivos específicos que não são rastreados - se possível, eu gostaria de manter o rastreamento desses arquivos.

Aqui está a abordagem da força bruta. Também remove a configuração do repositório.

Nota : Isso NÃO funciona se o repositório tiver submódulos! Se você estiver usando submódulos, deverá usar, por exemplo, rebase interativa

Etapa 1: remover todo o histórico ( verifique se você tem backup, isso não pode ser revertido )

cat .git/config  # note <github-uri>
rm -rf .git

Etapa 2: reconstruir o repositório Git apenas com o conteúdo atual

git init
git add .
git commit -m "Initial commit"

Etapa 3: pressione o GitHub.

git remote add origin <github-uri>
git push -u --force origin master

A única solução que funciona para mim (e mantém os submódulos funcionando) é

git checkout --orphan newBranch
git add -A  # Add all files and commit them
git commit
git branch -D master  # Deletes the master branch
git branch -m master  # Rename the current branch to master
git push -f origin master  # Force push master branch to github
git gc --aggressive --prune=all     # remove the old files

A exclusão .git/sempre causa problemas enormes quando tenho submódulos. O uso de git rebase --rootalguma forma causaria conflitos para mim (e levaria muito tempo, pois eu tinha muita história).

Esta é a minha abordagem preferida:

git branch new_branch_name $(echo "commit message" | git commit-tree HEAD^{tree})

Isso criará um novo ramo com um commit que adiciona tudo no HEAD. Não altera mais nada, por isso é completamente seguro.

A outra opção, que pode resultar em muito trabalho, se você tiver muitos commits, é uma rebase interativa (assumindo que sua versão do git seja> = 1.7.12):git rebase --root -i

Quando apresentado com uma lista de confirmações no seu editor:

• Altere "pick" para "reformular" para o primeiro commit
• Altere "pick" para "consertar" todos os outros commit

Salvar e fechar. O Git começará a ser reformulado.

No final, você teria um novo commit raiz que é uma combinação de todos os que vieram depois dele.

A vantagem é que você não precisa excluir seu repositório e, se tiver dúvidas, sempre terá um substituto.

Se você realmente deseja aprimorar seu histórico, redefina o mestre para esse commit e exclua todos os outros ramos.

Variante do método proposto por larsmans :

Salve sua lista de arquivos não rastreados:

git ls-files --others --exclude-standard > /tmp/my_untracked_files

Salve sua configuração do git:

mv .git/config /tmp/

Em seguida, execute os primeiros passos de larsmans:

rm -rf .git
git init
git add .

Restaure sua configuração:

mv /tmp/config .git/

Rastreie seus arquivos não rastreados:

cat /tmp/my_untracked_files | xargs -0 git rm --cached

Em seguida, confirme:

git commit -m "Initial commit"

E, finalmente, envie para o seu repositório:

git push -u --force origin master

Abaixo está um script adaptado da resposta de @Zeelot. Ele deve remover o histórico de todas as ramificações, não apenas da ramificação principal:

for BR in $(git branch); do   
  git checkout $BR
  git checkout --orphan ${BR}_temp
  git commit -m "Initial commit"
  git branch -D $BR
  git branch -m $BR
done;
git gc --aggressive --prune=all

Funcionou para meus propósitos (não estou usando submódulos).

Você pode usar clones rasos (git> 1.9):

git clone --depth depth remote-url

Leitura adicional: http://blogs.atlassian.com/2014/05/handle-big-repositories-git/

git filter-branch é a ferramenta de cirurgia principal.

git filter-branch --parent-filter true -- @^!

--parent-filtercoloca os pais no stdin e deve imprimir os pais reescritos no stdout; O unix truesai com sucesso e imprime nada, então: sem pais. @^!é uma abreviação do Git para "o chefe compromete, mas nenhum de seus pais". Em seguida, exclua todos os outros árbitros e empurre à vontade.

Basta excluir o repositório do Github e criar um novo. De longe, a abordagem mais rápida, fácil e segura. Afinal, o que você precisa obter ao executar todos esses comandos na solução aceita quando tudo o que você deseja é o ramo principal com uma única confirmação?

O método abaixo é exatamente reproduzível, portanto, não há necessidade de executar o clone novamente se os dois lados forem consistentes; basta executar o script do outro lado também.

git log -n1 --format=%H >.git/info/grafts
git filter-branch -f
rm .git/info/grafts

Se você quiser limpá-lo, tente este script:

http://sam.nipl.net/b/git-gc-all-ferocious

Eu escrevi um script que "mata histórico" para cada ramificação no repositório:

http://sam.nipl.net/b/git-kill-history

veja também: http://sam.nipl.net/b/confirm

O que eu gostaria de fazer é remover TODO o histórico de versões do repositório Git local, para que o conteúdo atual do repositório apareça como o único commit (e, portanto, as versões mais antigas dos arquivos no repositório não são armazenadas).

Uma resposta mais conceitual:

O git garbage coleta automaticamente commits antigos se nenhuma tag / branches / refs apontar para eles. Então você simplesmente precisa remover todas as tags / branches e criar um novo commit órfão, associado a qualquer branch - por convenção, você deixaria o branch masterapontar para esse commit.

As confirmações antigas e inacessíveis nunca mais serão vistas por ninguém, a menos que elas pesquisem com comandos git de baixo nível. Se isso é suficiente para você, eu apenas pararia por aí e deixaria o GC automático fazer seu trabalho sempre que desejar. Se você quiser se livrar deles imediatamente, pode usar git gc(possivelmente com --aggressive --prune=all). Para o repositório remoto do git, não há como forçar isso, a menos que você tenha acesso ao shell do sistema de arquivos.

Aqui está:

#!/bin/bash
#
# By Zibri (2019)
#
# Usage: gitclean username password giturl
#
gitclean () 
{ 
    odir=$PWD;
    if [ "$#" -ne 3 ]; then
        echo "Usage: gitclean username password giturl";
        return 1;
    fi;
    temp=$(mktemp -d 2>/dev/null /dev/shm/git.XXX || mktemp -d 2>/dev/null /tmp/git.XXX);
    cd "$temp";
    url=$(echo "$3" |sed -e "s/[^/]*\/\/\([^@]*@\)\?\.*/\1/");
    git clone "https://$1:$2@$url" && { 
        cd *;
        for BR in "$(git branch|tr " " "\n"|grep -v '*')";
        do
            echo working on branch $BR;
            git checkout $BR;
            git checkout --orphan $(basename "$temp"|tr -d .);
            git add -A;
            git commit -m "Initial Commit" && { 
                git branch -D $BR;
                git branch -m $BR;
                git push -f origin $BR;
                git gc --aggressive --prune=all
            };
        done
    };
    cd $odir;
    rm -rf "$temp"
}

Também hospedado aqui: https://gist.github.com/Zibri/76614988478a076bbe105545a16ee743

Resolvi um problema semelhante apenas excluindo a .gitpasta do meu projeto e reintegrando-o com o controle de versão através do IntelliJ. Nota: A .gitpasta está oculta. Você pode vê-lo no terminal com ls -ae, em seguida, removê-lo usando rm -rf .git.

Para isso, use o comando Shallow Clone git clone - profundidade 1 URL - Clona apenas o HEAD atual do repositório

Para remover o último commit do git, você pode simplesmente executar

git reset --hard HEAD^ 

Se você estiver removendo várias confirmações da parte superior, poderá executar

git reset --hard HEAD~2 

para remover os dois últimos commits. Você pode aumentar o número para remover ainda mais confirmações.

Mais informações aqui.

O tutoturial do Git aqui fornece ajuda sobre como limpar o repositório:

você deseja remover o arquivo do histórico e adicioná-lo ao .gitignore para garantir que ele não seja confirmado acidentalmente. Para nossos exemplos, removeremos o Rakefile do repositório de gemas do GitHub.

git clone https://github.com/defunkt/github-gem.git

cd github-gem

git filter-branch --force --index-filter \
  'git rm --cached --ignore-unmatch Rakefile' \
  --prune-empty --tag-name-filter cat -- --all

Agora que apagamos o arquivo do histórico, vamos garantir que não o comprometamos acidentalmente novamente.

echo "Rakefile" >> .gitignore

git add .gitignore

git commit -m "Add Rakefile to .gitignore"

Se você estiver satisfeito com o estado do repositório, precisará forçar as alterações para substituir o repositório remoto.

git push origin master --force