How to Create a Different Git Repository for a Subdirectory

Starting Fresh: Creating a New Repository from a Subdirectory

It is not unusual to discover that one of the subdirectories in a complicated Git repository has become distinct enough to require its own repository while handling a large number of them. By dividing a subdirectory and keeping its commit history intact, this procedure can support continued development by preserving continuity and context.

This process is better than just cloning the entire repository and deleting unnecessary portions because the latter preserves the entire history, which may not be useful or essential. Rather, the goal is to create a more organized, laser-focused repository that seems to have existed independently from the start.

Detailed Workflow Explanation

Detaching a subdirectory ('ABC' in this case) from a bigger Git repository and creating a standalone repository is made easier by the given scripts. Using the git filter-branch --subdirectory-filter ABC HEAD command is essential in this situation because it modifies the history of the repository, removing all irrelevant information and establishing 'ABC' as the root directory. By ensuring that the new repository will only include contributions that impact the 'ABC' directory, this step helps to provide a clear and targeted history for the directory.

Following the rewriting of the history, the script creates a new repository called "ABC" and links and pushes the freshly filtered history to it using the git remote add and git push commands. By deleting obsolete references and compressing file storage, commands like git gc --aggressive and git prune are used post-process to optimize repository space, which improves performance and lessens clutter in the new project environment.

git clone https://example.com/your-repo.git temp-repo
cd temp-repo
git filter-branch --prune-empty --subdirectory-filter ABC HEAD
mkdir ABC
mv * ABC/
git add .
git commit -m "Reorganize ABC files into a new directory structure"
cd ..
git init --bare new-ABC-repo.git
cd temp-repo
git remote add new-origin ../new-ABC-repo.git
git push new-origin master
cd ..
rm -rf temp-repo

git clone --no-hardlinks temp-repo original-repo
cd temp-repo
git filter-branch --tag-name-filter cat --prune-empty --subdirectory-filter ABC -- --all
git reset --hard
git gc --aggressive
git prune
git remote remove origin
git remote add origin https://example.com/new-ABC-repo.git
git push -u origin master
cd ..
rm -rf temp-repo

Advanced Methods for Managing Git Subdirectories

It's often helpful to think about more complex methods, like handling subprojects using git subtree rather than git submodules, when managing huge Git repositories. With the git subtree technique, you may add any repository as a subfolder of another repository, making it easier to handle dependencies as you don't need to have separate repository links like submodules do. When managing huge codebases with multiple teams working on separate project components, this technique is quite helpful.

Additionally, compared to git submodules, git subtree makes it easier to integrate changes from the main project and the subproject. One project's history can be maintained by embedding its contents inside another, which simplifies tracking changes and reverting to earlier versions without introducing additional problems from the interrelated histories of several submodules.