CODEWITHSUNDEEP
gitgithubgit-fork
Rafe
Rafe

Reputation: 9295

Copy a git repo without history

I have a private repository on GitHub that I want to make public. However, some of the initial commits contain information that I don't want to publicize (hard-coded credentials, etc).

What is the easiest route to make the latest commit public (I don't really need or want the previous commits in the public repository) without including some or all of the commit history?

Upvotes: 387

Views: 241980

Answers (8)

Gauthier
Gauthier

Reputation: 42035

You can limit the depth of the history while cloning:

--depth <depth>
Create a shallow clone with a history truncated to the specified 
number of revisions.

Use this if you want limited history, but still some.

But how do you place your new clone on github? You cannot just push a new repository to an account, you need a repo to push to.

You should probably:

  • make a local shallow clone as described above
  • create a new empty repo on github, with no content
  • add the github repo as a remote in your local shallow clone
  • push your HEAD of interest (probably main) to that new remote.

Paraphrased from this doc.

Upvotes: 562

timo kranz
timo kranz

Reputation: 163

#!/bin/bash
set -e

# Settings
user=xxx
pass=xxx
dir=xxx
repo_src=xxx
repo_trg=xxx
src_branch=xxx

repo_base_url=https://$user:[email protected]/$user
repo_src_url=$repo_base_url/$repo_src.git
repo_trg_url=$repo_base_url/$repo_trg.git

echo "Clone Source..."
git clone --depth 1 -b $src_branch $repo_src_url $dir

echo "CD"
cd ./$dir

echo "Remove GIT"
rm -rf .git

echo "Init GIT"
git init
git add .
git commit -m "Initial Commit"
git remote add origin $repo_trg_url

echo "Push..."
git push -u origin master

Upvotes: 6

J W
J W

Reputation: 1360

Deleting the .git folder is probably the easiest path since you don't want/need the history (as Stephan said).

So you can create a new repo from your latest commit: (How to clone seed/kick-start project without the whole history?)

git clone <git_url>

then delete .git, and afterwards run

git init

Or if you want to reuse your current repo: Make the current commit the only (initial) commit in a Git repository?

Follow the above steps then:

git add .
git commit -m "Initial commit"

Push to your repo.

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

Upvotes: 87

Niv
Niv

Reputation: 619

A lot of the answers here use the git clone --depth 1 which keeps the last commit (include the commit message).

If you wish to change the last commit message (from the cloned branch) you can use after the clone the command: git commit --amend -m "UPDATED MESSAGE HERE".

Upvotes: 1

Ralf
Ralf

Reputation: 11

Firstly, I should say that if there are only a few commits containing sensitive information, you'd be better to use git rebase -i to remove them. But that can get complicated when those files have been touched frequently. Also, it's very hard to get rid of the initial commit using git-rebase, so if your initial commit contains the things you want to delete, then things get harder.

But anyway, all of the answers above to fold the entire repo into one commit seem overly complicated, and will also be quite slow involving lots of intermediate directories and possibly trashing all the other configuration stored in .git.

A far quicker approach is to create an orphaned commit that exactly matches an existing commit, for example:

$ TREE=`git cat-file -p master |sed '1,/^$/s/^tree //p;d;'`
$ COMMIT=`echo Truncated tree | git commit-tree $TREE`
$ git branch truncated-master $COMMIT

Replace master and truncated-master as appropriate, and change the commit message as you see fit. If you're feeling really brave, go ahead and:

$ git branch backup-master-just-in-case-i-regret-it-later master
$ git push -f origin truncated-master:master

But, I would really avoid doing this last step if I were you, as it will cause problems for every other person currently using the repo. Instead, just switch to using this new branch (maybe with a better name) and don't publicise the old one.

Upvotes: 1

Zo&#235; Turner
Zo&#235; Turner

Reputation: 509

You could set the GitHub repository to be a template (by going to settings and selecting the option just under the repository name). A button saying "Use this template" will then appear on the Code page. This copies over all the files but removes all history and if you keep the original repo as private, this doesn't show any details under the repo name (note that it will show on your site as you own both but not to anyone else). It's only if the repo is public that a link to the original repo appears under the repo name.

Upvotes: 7

xaxxon
xaxxon

Reputation: 19791

Isn't this exactly what squashing a rebase does? Just squash everything except the last commit and then (force) push it.

Upvotes: 1

Agam Rafaeli-Farhadian
Agam Rafaeli-Farhadian

Reputation: 6043

Use the following command:

git clone --depth <depth> -b <branch> <repo_url>

Where:

  • depth is the amount of commits you want to include. i.e. if you just want the latest commit use git clone --depth 1
  • branch is the name of the remote branch that you want to clone from. i.e. if you want the last 3 commits from master branch use git clone --depth 3 -b master
  • repo_url is the url of your repository

Upvotes: 503

Related Questions