¿Hacer que la confirmación actual sea la única confirmación (inicial) en un repositorio Git?

Actualmente tengo un repositorio local de Git, que envío a un repositorio de Github.

El repositorio local tiene ~ 10 confirmaciones, y el repositorio de Github es un duplicado sincronizado de esto.

Lo que me gustaría hacer es eliminar TODO el historial de versiones del repositorio Git local, para que el contenido actual del repositorio aparezca como el único compromiso (y, por lo tanto, las versiones anteriores de los archivos dentro del repositorio no se almacenan).

Entonces me gustaría enviar estos cambios a Github.

He investigado Git rebase, pero esto parece ser más adecuado para eliminar versiones específicas. Otra posible solución es eliminar el repositorio local y crear uno nuevo, ¡aunque esto probablemente generaría mucho trabajo!

ETA: Hay directorios / archivos específicos que no se rastrean; si es posible, me gustaría mantener el seguimiento de estos archivos.

Aquí está el enfoque de fuerza bruta. También elimina la configuración del repositorio.

Nota : ¡Esto NO funciona si el repositorio tiene submódulos! Si está usando submódulos, debe usar, por ejemplo, rebase interactivo

Paso 1: elimine todo el historial ( asegúrese de tener una copia de seguridad, no se puede revertir )

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

Paso 2: reconstruya el repositorio de Git solo con el contenido actual

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

Paso 3: empuja a GitHub.

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

La única solución que funciona para mí (y mantiene funcionando los submódulos) es

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

Eliminar .git/siempre causa grandes problemas cuando tengo submódulos. Usar de git rebase --rootalguna manera me causaría conflictos (y llevaría mucho tiempo desde que tenía mucha historia).

Este es mi enfoque favorito:

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

Esto creará una nueva rama con una confirmación que agrega todo en HEAD. No altera nada más, por lo que es completamente seguro.

La otra opción, que podría resultar mucho trabajo si tienes muchos commits, es un rebase interactivo (suponiendo que tu versión de git sea> = 1.7.12):git rebase --root -i

Cuando se le presenta una lista de confirmaciones en su editor:

• Cambie "pick" a "reword" para la primera confirmación
• Cambie "pick" a "fixup" cada otro commit

Guardar y cerrar. Git comenzará a rebasar.

Al final, tendría una nueva confirmación de raíz que es una combinación de todas las que vinieron después.

La ventaja es que no tiene que eliminar su repositorio y si tiene dudas, siempre tiene un respaldo.

Si realmente desea destruir su historial, restablezca el maestro a esta confirmación y elimine todas las demás ramas.

Variante del método propuesto por larsmans :

Guarde su lista de archivos sin seguimiento:

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

Guarde su configuración de git:

mv .git/config /tmp/

Luego realice los primeros pasos de larsmans:

rm -rf .git
git init
git add .

Restaura tu configuración:

mv /tmp/config .git/

Destraza tus archivos sin seguimiento:

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

Entonces cometer:

git commit -m "Initial commit"

Y finalmente empuje a su repositorio:

git push -u --force origin master

A continuación se muestra un script adaptado de la respuesta de @Zeelot. Debe eliminar el historial de todas las ramas, no solo la rama maestra:

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

Funcionó para mis propósitos (no estoy usando submódulos).

Puede usar clones poco profundos (git> 1.9):

git clone --depth depth remote-url

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

git filter-branch es la herramienta de cirugía mayor.

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

--parent-filterpone a los padres en stdin y debe imprimir los padres reescritos en stdout; Unix truesale con éxito y no imprime nada, así que no hay padres. @^!es la abreviatura de Git para "el responsable principal pero ninguno de sus padres". Luego borre todas las otras referencias y empuje a su gusto.

Simplemente elimine el repositorio de Github y cree uno nuevo. Con mucho, el enfoque más rápido, fácil y seguro. Después de todo, ¿qué tiene que ganar al ejecutar todos esos comandos en la solución aceptada cuando todo lo que desea es la rama maestra con una sola confirmación?

El siguiente método es exactamente reproducible, por lo que no es necesario ejecutar clon nuevamente si ambos lados son consistentes, solo ejecute el script en el otro lado también.

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

Si luego quieres limpiarlo, prueba este script:

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

Escribí un script que "mata la historia" para cada rama en el repositorio:

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

ver también: http://sam.nipl.net/b/confirm

Lo que me gustaría hacer es eliminar TODO el historial de versiones del repositorio Git local, para que el contenido actual del repositorio aparezca como el único compromiso (y, por lo tanto, las versiones anteriores de los archivos dentro del repositorio no se almacenan).

Una respuesta más conceptual:

git basura automáticamente recopila confirmaciones antiguas si no hay etiquetas / ramas / referencias que las señalen. Entonces, simplemente tiene que eliminar todas las etiquetas / ramas y crear una nueva confirmación huérfana, asociada con cualquier rama; por convención, dejaría que la rama masterapunte a esa confirmación.

Los viejos commits inalcanzables nunca serán vistos por nadie a menos que vayan a cavar con comandos git de bajo nivel. Si eso es suficiente para usted, simplemente me detendría allí y dejaría que el GC automático haga su trabajo cuando lo desee. Si desea deshacerse de ellos de inmediato, puede usarlos git gc(posiblemente con --aggressive --prune=all). Sin embargo, para el repositorio de git remoto, no hay forma de forzarlo, a menos que tenga acceso de shell a su sistema de archivos.

Aqui tienes:

#!/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"
}

También alojado aquí: https://gist.github.com/Zibri/76614988478a076bbe105545a16ee743

Resolví un problema similar simplemente borrando la .gitcarpeta de mi proyecto y reintegrando con el control de versiones a través de IntelliJ. Nota: la .gitcarpeta está oculta. Puede verlo en el terminal con ls -a, y luego eliminarlo usando rm -rf .git.

Para eso, use el comando Shallow Clone git clone --depth 1 URL - Clonará solo el HEAD actual del repositorio

Para eliminar la última confirmación de git, simplemente puede ejecutar

git reset --hard HEAD^ 

Si está eliminando varias confirmaciones desde la parte superior, puede ejecutar

git reset --hard HEAD~2 

para eliminar las dos últimas confirmaciones. Puede aumentar el número para eliminar aún más confirmaciones.

Más información aquí.

Git tutoturial aquí proporciona ayuda sobre cómo purgar el repositorio:

desea eliminar el archivo del historial y agregarlo al .gitignore para asegurarse de que no se vuelva a confirmar accidentalmente. Para nuestros ejemplos, vamos a eliminar Rakefile del repositorio de gemas 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

Ahora que hemos borrado el archivo del historial, asegurémonos de no volver a comprometerlo accidentalmente.

echo "Rakefile" >> .gitignore

git add .gitignore

git commit -m "Add Rakefile to .gitignore"

Si está satisfecho con el estado del repositorio, debe forzar los cambios para sobrescribir el repositorio remoto.

git push origin master --force