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?

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.

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

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: (https://stackoverflow.com/questions/29748197/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: https://stackoverflow.com/questions/9683279/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

#!/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:$pass@bitbucket.org/$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

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.

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.

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

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".