How to Merge Repositories in GitHub?

In collaborative software development, managing multiple repositories can sometimes become a challenge, especially when it makes sense to consolidate them. Merging repositories on GitHub can simplify your workflow, streamline project management, and consolidate codebases. However, merging repositories is not as straightforward as merging branches, and it requires careful planning and execution to avoid losing valuable code and history.

In this blog, we will walk you through the process of merging two GitHub repositories into one, covering the necessary steps, best practices, and common pitfalls to avoid.

Why Merge GitHub Repositories?

Before diving into the steps, it’s important to understand why you might want to merge repositories:

1. Consolidate Codebases: You may want to bring related code from multiple repositories into a single repository for easier management and collaboration.
2. Simplify Dependency Management: Merging repositories can help manage dependencies or related code under a single project, making it easier for contributors to access and contribute to the same codebase.
3. Centralized Project Management: If you’ve been working on multiple repositories for the same project, consolidating them into one can simplify issue tracking, CI/CD pipelines, and versioning.
4. Retire Unused Repositories: Merging old repositories into a new one can help reduce clutter and maintain a clean set of repositories.

---

Best Practices Before Merging Repositories

Before starting the process, it’s crucial to take a few preparatory steps to ensure a smooth transition:

1. Backup Both Repositories: Always create backups of the repositories you’re merging. You can do this by cloning both repositories to your local machine and pushing them to a new remote location.

   git clone https://github.com/username/repo1.git
   git clone https://github.com/username/repo2.git

2. Review and Clean Up: Ensure that both repositories are well-organized and that you’re only merging relevant code. Remove any unnecessary or obsolete files that don’t need to be part of the new, merged repository.
3. Consider Branch Naming and History: Keep in mind that the commit history of both repositories will be preserved. It’s important to decide whether you want to keep the commit history from both repositories or if you’d prefer to flatten the history into a single, clean commit.

---

Steps to Merge Two GitHub Repositories

Once you’ve prepared the repositories, follow these steps to merge them into one. We will assume that you’re merging repo2 into repo1.

Step 1: Create a New Repository (Optional)

If you want to merge the two repositories into a new one, you can create a new repository on GitHub. If you’re merging into an existing repository, you can skip this step.

1. Go to GitHub and create a new repository (e.g., merged-repo).
2. Clone the new repository to your local machine:

   git clone https://github.com/username/merged-repo.git
   cd merged-repo

Step 2: Add the Second Repository as a Remote

Now, you need to add the second repository (e.g., repo2) as a remote to your primary repository (e.g., repo1).

1. Navigate to the directory of the repository you want to merge into (the “main” repository). For example, if you’re merging repo2 into repo1, navigate to repo1:

   cd repo1

2. Add the second repository (repo2) as a remote:

   git remote add repo2 https://github.com/username/repo2.git

3. Fetch the content from repo2 to ensure you have all the latest changes:

   git fetch repo2

Step 3: Create a New Directory for the Merged Repository

To avoid conflicts, it’s often a good idea to keep the code from repo2 in a separate directory within repo1.

1. Create a new directory where the code from repo2 will be placed:

   mkdir repo2-code

2. Switch to the directory of the second repository (repo2):

   git checkout repo2/main  # Or the branch you want to merge

3. Copy all files from repo2 into the new directory (repo2-code):

   git ls-tree --name-only -r HEAD | xargs -I files cp -r files ../repo2-code/

Step 4: Commit and Push Changes

Once you’ve copied the files from repo2 into the new directory, it’s time to commit the changes:

1. Stage the changes:

   git add .

2. Commit the changes to your current branch:

   git commit -m "Merged repo2 into repo1"

3. Push the changes to GitHub:

   git push origin main

Step 5: Resolve Conflicts (If Any)

During the merging process, conflicts may arise, especially if the two repositories have similar files or directories. If this happens, you’ll need to resolve conflicts manually:

1. Git will indicate the conflicting files. Open these files in your text editor and resolve the conflicts.
2. After resolving conflicts, mark them as resolved:

   git add <file-name>

3. Once all conflicts are resolved, commit the changes:

   git commit -m "Resolved conflicts during repository merge"

4. Finally, push the resolved changes:

   git push origin main

---

Step 6: Clean Up

After merging the repositories, you can delete the remote reference to repo2 to keep your repository clean:

git remote remove repo2

Additionally, if you want to delete the now redundant repository (repo2), you can remove it from GitHub (optional).

---

Final Thoughts on Merging Repositories

Merging repositories on GitHub can be a great way to consolidate codebases, simplify project management, and ensure everything is in one place. However, this process requires careful handling, especially when it comes to managing commit history, resolving conflicts, and maintaining a clean directory structure.

Key Takeaways:

1. Backup Your Repositories: Always clone and back up your repositories before starting the merge process.
2. Use Separate Directories: Keep the merged repository’s code in separate directories to avoid conflicts and ensure clarity.
3. Resolve Conflicts Carefully: Be mindful of any potential conflicts between the two codebases.
4. Clean Up: Remove unnecessary remotes and repositories once the merge is complete.

By following these steps and best practices, you’ll be able to successfully merge repositories in GitHub without losing valuable code or history.