考虑以下场景：
我在自己的 Git 存储库中开发了一个小型实验项目 A。它现在已经成熟，我希望 A 成为更大的项目 B 的一部分，它有自己的大存储库。我现在想将 A 添加为 B 的子目录。
如何在不丢失任何历史记录的情况下将 A 合并到 B 中？
问问题
587225 次
26 回答
2374
如果你想合并project-a到project-b：
cd path/to/project-b
git remote add project-a /path/to/project-a
git fetch project-a --tags
git merge --allow-unrelated-histories project-a/master # or whichever branch you want to merge
git remote remove project-a
取自：git merge different repositories?
这种方法对我来说效果很好，它更短，在我看来更干净。
如果您想放入project-a子目录，您可以使用git-filter-repo(filter-branch不鼓励)。在上述命令之前运行以下命令：
cd path/to/project-a
git filter-repo --to-subdirectory-filter project-a
合并 2 个大存储库的示例，将其中一个放入子目录：https ://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731
注意：该--allow-unrelated-histories参数仅在 git >= 2.9 后才存在。请参阅Git - git merge 文档/--allow-unrelated-histories
更新：--tags按照@jstadler 的建议添加以保留标签。
于 2012-05-11T09:37:09.730 回答
638
以下是两种可能的解决方案：
子模块
将存储库 A 复制到较大项目 B 中的单独目录中，或者（也许更好）将存储库 A 克隆到项目 B 的子目录中。然后使用git submodule将此存储库作为存储库 B的子模块。
对于松散耦合的存储库来说，这是一个很好的解决方案，其中存储库 A 中的开发仍在继续，开发的主要部分是 A 中的单独独立开发。另请参阅Git Wiki 上的SubmoduleSupport和GitSubmoduleTutorial页面。
子树合并
您可以使用子树合并策略将存储库 A 合并到项目 B 的子目录中。这在Markus Prinz的Subtree Merging and You中有描述。
git remote add -f Bproject /path/to/B
git merge -s ours --allow-unrelated-histories --no-commit Bproject/master
git read-tree --prefix=dir-B/ -u Bproject/master
git commit -m "Merge B project as our subdirectory"
git pull -s subtree Bproject master
（--allow-unrelated-historiesGit >= 2.9.0 需要选项。）
或者您可以使用apenwarr (Avery Pennarun) 的git subtree工具（GitHub 上的存储库），例如在他的博客文章中宣布了Git 子模块的新替代方案：git subtree。
我认为在您的情况下（A 将成为较大项目 B 的一部分），正确的解决方案是使用subtree merge。
于 2009-09-15T09:38:42.673 回答
501
另一个存储库的单个分支可以很容易地放置在保留其历史记录的子目录下。例如：
git subtree add --prefix=rails git://github.com/rails/rails.git master
这将显示为单个提交，其中 Rails 主分支的所有文件都添加到“rails”目录中。然而，提交的标题包含对旧历史树的引用：
从提交中添加“rails/”
<rev>
<rev>SHA-1 提交哈希在哪里。你仍然可以看到历史，责怪一些变化。
git log <rev>
git blame <rev> -- README.md
请注意，您无法从此处看到目录前缀，因为这是一个完好无损的实际旧分支。您应该将其视为通常的文件移动提交：到达它时您将需要额外的跳转。
# finishes with all files added at once commit
git log rails/README.md
# then continue from original tree
git log <rev> -- README.md
有更复杂的解决方案，例如手动执行此操作或重写其他答案中描述的历史记录。
git-subtree 命令是官方 git-contrib 的一部分，一些数据包管理器默认安装它（OS X Homebrew）。但是除了 git 之外，您可能还必须自己安装它。
于 2013-02-20T23:44:27.257 回答
206
如果您想单独维护项目，则子模块方法很好。但是，如果您真的想将两个项目合并到同一个存储库中，那么您还有更多工作要做。
第一件事是使用git filter-branch重写第二个存储库中所有内容的名称，使其位于您希望它们结束的子目录中。因此，您将拥有and而不是foo.c, 。bar.htmlprojb/foo.cprojb/bar.html
然后，您应该能够执行以下操作：
git remote add projb [wherever]
git pull projb
将git pull执行 agit fetch后跟 a git merge。如果您要拉到的存储库还没有projb/目录，则应该没有冲突。
进一步的搜索表明做了类似的事情来合并gitk到git. Junio C Hamano 在这里写到：http: //www.mail-archive.com/git@vger.kernel.org/msg03395.html
于 2009-09-15T08:38:49.507 回答
77
git-subtree很好，但它可能不是你想要的。
比如如果projectA是B中创建的目录，之后git subtree，
git log projectA
仅列出一个提交：合并。合并项目的提交用于不同的路径，因此它们不会显示。
Greg Hewgill 的答案最接近，尽管它实际上并没有说明如何重写路径。
解决方案非常简单。
(1) 在 A 中，
PREFIX=projectA #adjust this
git filter-branch --index-filter '
git ls-files -s |
sed "s,\t,&'"$PREFIX"'/," |
GIT_INDEX_FILE=$GIT_INDEX_FILE.new git update-index --index-info &&
mv $GIT_INDEX_FILE.new $GIT_INDEX_FILE
' HEAD
注意：这会改写历史；您可能需要先备份 A。
注意：如果您在文件名或路径中使用非 ascii 字符（或白色字符），则必须修改 sed 命令中的替换脚本。在这种情况下，由“ls-files -s”生成的记录中的文件位置以引号开头。
(2) 然后在 B 中运行
git pull path/to/A
瞧！您在 B 中有一个projectA目录。如果您运行git log projectA，您将看到来自 A 的所有提交。
就我而言，我想要两个子目录，projectA和projectB. 在这种情况下，我也对 B 执行了步骤 (1)。
于 2014-02-01T08:10:09.617 回答
60
如果两个存储库具有相同类型的文件（例如不同项目的两个 Rails 存储库），您可以将辅助存储库的数据获取到当前存储库：
git fetch git://repository.url/repo.git master:branch_name
然后将其合并到当前存储库：
git merge --allow-unrelated-histories branch_name
如果您的 Git 版本小于 2.9，请删除--allow-unrelated-histories.
在此之后，可能会发生冲突。例如，您可以使用git mergetool. kdiff3可以单独与键盘一起使用，因此在读取代码时只需几分钟就需要 5 个冲突文件。
记得完成合并：
git commit
于 2011-06-11T14:31:33.217 回答
31
在使用合并时，我一直在丢失历史记录，所以我最终使用了 rebase，因为在我的情况下，两个存储库不同，以至于不会在每次提交时合并：
git clone git@gitorious/projA.git projA
git clone git@gitorious/projB.git projB
cd projB
git remote add projA ../projA/
git fetch projA
git rebase projA/master HEAD
=> 解决冲突，然后继续，根据需要多次...
git rebase --continue
这样做会导致一个项目拥有来自 projA 的所有提交，然后是来自 projB 的提交
于 2014-02-27T03:09:17.523 回答
27
就我而言，我有一个my-plugin存储库和一个main-project存储库，我想假装它一直my-plugin是在.pluginsmain-project
基本上，我重写了存储库的历史，my-plugin以便所有开发都发生在plugins/my-plugin子目录中。然后，我将开发历史添加my-plugin到main-project历史记录中，并将两棵树合并在一起。由于存储库中没有plugins/my-plugin目录main-project，这是一个简单的无冲突合并。生成的存储库包含两个原始项目的所有历史记录，并且有两个根源。
TL;博士
$ cp -R my-plugin my-plugin-dirty
$ cd my-plugin-dirty
$ git filter-branch -f --tree-filter "zsh -c 'setopt extended_glob && setopt glob_dots && mkdir -p plugins/my-plugin && (mv ^(.git|plugins) plugins/my-plugin || true)'" -- --all
$ cd ../main-project
$ git checkout master
$ git remote add --fetch my-plugin ../my-plugin-dirty
$ git merge my-plugin/master --allow-unrelated-histories
$ cd ..
$ rm -rf my-plugin-dirty
长版
首先，创建存储库的副本my-plugin，因为我们将重写此存储库的历史记录。
现在，导航到存储库的根目录my-plugin，检查您的主分支（可能master），然后运行以下命令。当然，您应该替换my-plugin任何plugins您的实际姓名。
$ git filter-branch -f --tree-filter "zsh -c 'setopt extended_glob && setopt glob_dots && mkdir -p plugins/my-plugin && (mv ^(.git|plugins) plugins/my-plugin || true)'" -- --all
现在解释一下。git filter-branch --tree-filter (...) HEAD在(...)可从HEAD. 请注意，这直接对每次提交存储的数据进行操作，因此我们不必担心“工作目录”、“索引”、“暂存”等概念。
如果你运行一个filter-branch失败的命令，它会在目录中留下一些文件，.git下次你尝试filter-branch它会抱怨这个，除非你-f提供filter-branch.
至于实际的命令，我没有太多运气bash来做我想做的事，所以我用zsh -cmake 来zsh执行命令。首先，我设置了extended_glob启用命令^(...)语法的选项，以及允许我选择带有 glob ( ) 的点文件（例如）的选项。mvglob_dots.gitignore^(...)
接下来，我使用mkdir -p命令同时创建plugins两者plugins/my-plugin。
最后，我使用zsh“负 glob”功能来匹配存储库根目录中的所有文件，但新创建的文件夹^(.git|plugins)除外。（此处可能不需要排除，但尝试将目录移动到自身中是错误的。）.gitmy-plugin.git
在我的存储库中，初始提交不包含任何文件，因此该mv命令在初始提交时返回错误（因为没有可移动的内容）。因此，我添加了一个|| true这样git filter-branch就不会中止。
该--all选项告诉filter-branch重写存储库中所有分支的历史记录，并且需要额外--告诉git将其解释为要重写的分支的选项列表的一部分，而不是作为其filter-branch自身的选项。
现在，导航到您的main-project存储库并检查您要合并到的任何分支。添加存储库的本地副本my-plugin（修改其历史）作为远程main-project：
$ git remote add --fetch my-plugin $PATH_TO_MY_PLUGIN_REPOSITORY
现在，您的提交历史中将有两个不相关的树，您可以使用以下方法很好地可视化它们：
$ git log --color --graph --decorate --all
要合并它们，请使用：
$ git merge my-plugin/master --allow-unrelated-histories
请注意，在 2.9.0 之前的 Git 中，该--allow-unrelated-histories选项不存在。如果您使用这些版本之一，只需省略该选项：--allow-unrelated-histories阻止的错误消息也在2.9.0 中添加。
您不应该有任何合并冲突。如果这样做，则可能意味着该filter-branch命令无法正常工作，plugins/my-plugin或者main-project.
确保为任何未来的贡献者输入一个解释性的提交消息，他们想知道黑客正在做什么来创建一个有两个根的存储库。
git log您可以使用上述命令可视化新的提交图，它应该有两个根提交。请注意，只有master分支会被合并。这意味着，如果您在my-plugin要合并到树中的其他分支上有重要工作，则在完成这些合并之前main-project，您应该避免删除远程。my-plugin如果您不这样做，那么来自这些分支的提交仍将在main-project存储库中，但有些将无法访问并且容易受到最终垃圾收集的影响。（此外，您必须通过 SHA 引用它们，因为删除远程会删除其远程跟踪分支。）
或者，在您合并所有要保留的内容后my-plugin，您可以使用以下方法删除my-plugin遥控器：
$ git remote remove my-plugin
您现在可以安全地删除my-plugin您更改了其历史记录的存储库的副本。my-plugin就我而言，在合并完成并推送后，我还在真实存储库中添加了弃用通知。
在 Mac OS X El Capitan 上使用git --version 2.9.0和zsh --version 5.2. 你的旅费可能会改变。
参考：
于 2016-08-18T21:06:44.387 回答
9
我在这里收集了很多关于 Stack OverFlow 等的信息，并设法将一个脚本放在一起，为我解决了这个问题。
需要注意的是，它只考虑每个存储库的“开发”分支，并将其合并到一个全新存储库中的单独目录中。
标签和其他分支被忽略 - 这可能不是你想要的。
该脚本甚至处理功能分支和标签 - 在新项目中重命名它们，以便您知道它们来自哪里。
#!/bin/bash
#
################################################################################
## Script to merge multiple git repositories into a new repository
## - The new repository will contain a folder for every merged repository
## - The script adds remotes for every project and then merges in every branch
## and tag. These are renamed to have the origin project name as a prefix
##
## Usage: mergeGitRepositories.sh <new_project> <my_repo_urls.lst>
## - where <new_project> is the name of the new project to create
## - and <my_repo_urls.lst> is a file contaning the URLs to the respositories
## which are to be merged on separate lines.
##
## Author: Robert von Burg
## eitch@eitchnet.ch
##
## Version: 0.3.2
## Created: 2018-02-05
##
################################################################################
#
# disallow using undefined variables
shopt -s -o nounset
# Script variables
declare SCRIPT_NAME="${0##*/}"
declare SCRIPT_DIR="$(cd ${0%/*} ; pwd)"
declare ROOT_DIR="$PWD"
IFS=$'\n'
# Detect proper usage
if [ "$#" -ne "2" ] ; then
echo -e "ERROR: Usage: $0 <new_project> <my_repo_urls.lst>"
exit 1
fi
## Script variables
PROJECT_NAME="${1}"
PROJECT_PATH="${ROOT_DIR}/${PROJECT_NAME}"
TIMESTAMP="$(date +%s)"
LOG_FILE="${ROOT_DIR}/${PROJECT_NAME}_merge.${TIMESTAMP}.log"
REPO_FILE="${2}"
REPO_URL_FILE="${ROOT_DIR}/${REPO_FILE}"
# Script functions
function failed() {
echo -e "ERROR: Merging of projects failed:"
echo -e "ERROR: Merging of projects failed:" >>${LOG_FILE} 2>&1
echo -e "$1"
exit 1
}
function commit_merge() {
current_branch="$(git symbolic-ref HEAD 2>/dev/null)"
if [[ ! -f ".git/MERGE_HEAD" ]] ; then
echo -e "INFO: No commit required."
echo -e "INFO: No commit required." >>${LOG_FILE} 2>&1
else
echo -e "INFO: Committing ${sub_project}..."
echo -e "INFO: Committing ${sub_project}..." >>${LOG_FILE} 2>&1
if ! git commit -m "[Project] Merged branch '$1' of ${sub_project}" >>${LOG_FILE} 2>&1 ; then
failed "Failed to commit merge of branch '$1' of ${sub_project} into ${current_branch}"
fi
fi
}
# Make sure the REPO_URL_FILE exists
if [ ! -e "${REPO_URL_FILE}" ] ; then
echo -e "ERROR: Repo file ${REPO_URL_FILE} does not exist!"
exit 1
fi
# Make sure the required directories don't exist
if [ -e "${PROJECT_PATH}" ] ; then
echo -e "ERROR: Project ${PROJECT_NAME} already exists!"
exit 1
fi
# create the new project
echo -e "INFO: Logging to ${LOG_FILE}"
echo -e "INFO: Creating new git repository ${PROJECT_NAME}..."
echo -e "INFO: Creating new git repository ${PROJECT_NAME}..." >>${LOG_FILE} 2>&1
echo -e "===================================================="
echo -e "====================================================" >>${LOG_FILE} 2>&1
cd ${ROOT_DIR}
mkdir ${PROJECT_NAME}
cd ${PROJECT_NAME}
git init
echo "Initial Commit" > initial_commit
# Since this is a new repository we need to have at least one commit
# thus were we create temporary file, but we delete it again.
# Deleting it guarantees we don't have conflicts later when merging
git add initial_commit
git commit --quiet -m "[Project] Initial Master Repo Commit"
git rm --quiet initial_commit
git commit --quiet -m "[Project] Initial Master Repo Commit"
echo
# Merge all projects into the branches of this project
echo -e "INFO: Merging projects into new repository..."
echo -e "INFO: Merging projects into new repository..." >>${LOG_FILE} 2>&1
echo -e "===================================================="
echo -e "====================================================" >>${LOG_FILE} 2>&1
for url in $(cat ${REPO_URL_FILE}) ; do
if [[ "${url:0:1}" == '#' ]] ; then
continue
fi
# extract the name of this project
export sub_project=${url##*/}
sub_project=${sub_project%*.git}
echo -e "INFO: Project ${sub_project}"
echo -e "INFO: Project ${sub_project}" >>${LOG_FILE} 2>&1
echo -e "----------------------------------------------------"
echo -e "----------------------------------------------------" >>${LOG_FILE} 2>&1
# Fetch the project
echo -e "INFO: Fetching ${sub_project}..."
echo -e "INFO: Fetching ${sub_project}..." >>${LOG_FILE} 2>&1
git remote add "${sub_project}" "${url}"
if ! git fetch --tags --quiet ${sub_project} >>${LOG_FILE} 2>&1 ; then
failed "Failed to fetch project ${sub_project}"
fi
# add remote branches
echo -e "INFO: Creating local branches for ${sub_project}..."
echo -e "INFO: Creating local branches for ${sub_project}..." >>${LOG_FILE} 2>&1
while read branch ; do
branch_ref=$(echo $branch | tr " " "\t" | cut -f 1)
branch_name=$(echo $branch | tr " " "\t" | cut -f 2 | cut -d / -f 3-)
echo -e "INFO: Creating branch ${branch_name}..."
echo -e "INFO: Creating branch ${branch_name}..." >>${LOG_FILE} 2>&1
# create and checkout new merge branch off of master
if ! git checkout -b "${sub_project}/${branch_name}" master >>${LOG_FILE} 2>&1 ; then failed "Failed preparing ${branch_name}" ; fi
if ! git reset --hard ; then failed "Failed preparing ${branch_name}" >>${LOG_FILE} 2>&1 ; fi
if ! git clean -d --force ; then failed "Failed preparing ${branch_name}" >>${LOG_FILE} 2>&1 ; fi
# Merge the project
echo -e "INFO: Merging ${sub_project}..."
echo -e "INFO: Merging ${sub_project}..." >>${LOG_FILE} 2>&1
if ! git merge --allow-unrelated-histories --no-commit "remotes/${sub_project}/${branch_name}" >>${LOG_FILE} 2>&1 ; then
failed "Failed to merge branch 'remotes/${sub_project}/${branch_name}' from ${sub_project}"
fi
# And now see if we need to commit (maybe there was a merge)
commit_merge "${sub_project}/${branch_name}"
# relocate projects files into own directory
if [ "$(ls)" == "${sub_project}" ] ; then
echo -e "WARN: Not moving files in branch ${branch_name} of ${sub_project} as already only one root level."
echo -e "WARN: Not moving files in branch ${branch_name} of ${sub_project} as already only one root level." >>${LOG_FILE} 2>&1
else
echo -e "INFO: Moving files in branch ${branch_name} of ${sub_project} so we have a single directory..."
echo -e "INFO: Moving files in branch ${branch_name} of ${sub_project} so we have a single directory..." >>${LOG_FILE} 2>&1
mkdir ${sub_project}
for f in $(ls -a) ; do
if [[ "$f" == "${sub_project}" ]] ||
[[ "$f" == "." ]] ||
[[ "$f" == ".." ]] ; then
continue
fi
git mv -k "$f" "${sub_project}/"
done
# commit the moving
if ! git commit --quiet -m "[Project] Move ${sub_project} files into sub directory" ; then
failed "Failed to commit moving of ${sub_project} files into sub directory"
fi
fi
echo
done < <(git ls-remote --heads ${sub_project})
# checkout master of sub probject
if ! git checkout "${sub_project}/master" >>${LOG_FILE} 2>&1 ; then
failed "sub_project ${sub_project} is missing master branch!"
fi
# copy remote tags
echo -e "INFO: Copying tags for ${sub_project}..."
echo -e "INFO: Copying tags for ${sub_project}..." >>${LOG_FILE} 2>&1
while read tag ; do
tag_ref=$(echo $tag | tr " " "\t" | cut -f 1)
tag_name_unfixed=$(echo $tag | tr " " "\t" | cut -f 2 | cut -d / -f 3)
# hack for broken tag names where they are like 1.2.0^{} instead of just 1.2.0
tag_name="${tag_name_unfixed%%^*}"
tag_new_name="${sub_project}/${tag_name}"
echo -e "INFO: Copying tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}..."
echo -e "INFO: Copying tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}..." >>${LOG_FILE} 2>&1
if ! git tag "${tag_new_name}" "${tag_ref}" >>${LOG_FILE} 2>&1 ; then
echo -e "WARN: Could not copy tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}"
echo -e "WARN: Could not copy tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}" >>${LOG_FILE} 2>&1
fi
done < <(git ls-remote --tags --refs ${sub_project})
# Remove the remote to the old project
echo -e "INFO: Removing remote ${sub_project}..."
echo -e "INFO: Removing remote ${sub_project}..." >>${LOG_FILE} 2>&1
git remote rm ${sub_project}
echo
done
# Now merge all project master branches into new master
git checkout --quiet master
echo -e "INFO: Merging projects master branches into new repository..."
echo -e "INFO: Merging projects master branches into new repository..." >>${LOG_FILE} 2>&1
echo -e "===================================================="
echo -e "====================================================" >>${LOG_FILE} 2>&1
for url in $(cat ${REPO_URL_FILE}) ; do
if [[ ${url:0:1} == '#' ]] ; then
continue
fi
# extract the name of this project
export sub_project=${url##*/}
sub_project=${sub_project%*.git}
echo -e "INFO: Merging ${sub_project}..."
echo -e "INFO: Merging ${sub_project}..." >>${LOG_FILE} 2>&1
if ! git merge --allow-unrelated-histories --no-commit "${sub_project}/master" >>${LOG_FILE} 2>&1 ; then
failed "Failed to merge branch ${sub_project}/master into master"
fi
# And now see if we need to commit (maybe there was a merge)
commit_merge "${sub_project}/master"
echo
done
# Done
cd ${ROOT_DIR}
echo -e "INFO: Done."
echo -e "INFO: Done." >>${LOG_FILE} 2>&1
echo
exit 0
您也可以从http://paste.ubuntu.com/11732805获取
首先创建一个包含每个存储库的 URL 的文件，例如：
git@github.com:eitchnet/ch.eitchnet.parent.git
git@github.com:eitchnet/ch.eitchnet.utils.git
git@github.com:eitchnet/ch.eitchnet.privilege.git
然后调用提供项目名称和脚本路径的脚本：
./mergeGitRepositories.sh eitchnet_test eitchnet.lst
脚本本身有很多注释应该解释它的作用。
于 2015-06-11T12:59:50.353 回答
9
几天来我一直在尝试做同样的事情，我使用的是 git 2.7.2。子树不保留历史。
如果您不再使用旧项目，您可以使用此方法。
我建议你先分支 B 并在分支中工作。
以下是没有分支的步骤：
cd B
# You are going to merge A into B, so first move all of B's files into a sub dir
mkdir B
# Move all files to B, till there is nothing in the dir but .git and B
git mv <files> B
git add .
git commit -m "Moving content of project B in preparation for merge from A"
# Now merge A into B
git remote add -f A <A repo url>
git merge A/<branch>
mkdir A
# move all the files into subdir A, excluding .git
git mv <files> A
git commit -m "Moved A into subdir"
# Move B's files back to root
git mv B/* ./
rm -rf B
git commit -m "Reset B to original state"
git push
如果您现在在 subdir A 中记录任何文件，您将获得完整的历史记录
git log --follow A/<file>
这是帮助我做到这一点的帖子：
于 2016-03-10T12:51:08.847 回答
9
如果您想将 repo B 中的分支中的文件放在 repo A 的子树中并保留历史记录，请继续阅读。（在下面的示例中，我假设我们希望将 repo B 的 master 分支合并到 repo A 的 master 分支中。）
在 repo A 中，首先执行以下操作以使 repo B 可用：
git remote add B ../B # Add repo B as a new remote.
git fetch B
现在我们在我们称之为的 repo A 中创建一个全新的分支（只有一个提交）new_b_root。生成的提交将包含在 repo B 的主分支的第一次提交中提交但放在名为path/to/b-files/.
git checkout --orphan new_b_root master
git rm -rf . # Remove all files.
git cherry-pick -n `git rev-list --max-parents=0 B/master`
mkdir -p path/to/b-files
git mv README path/to/b-files/
git commit --date="$(git log --format='%ai' $(git rev-list --max-parents=0 B/master))"
说明：--orphancheckout 命令的选项从 A 的 master 分支中签出文件，但不创建任何提交。我们可以选择任何提交，因为接下来我们无论如何都会清除所有文件。然后，还没有提交（-n），我们从 B 的主分支中挑选第一个提交。（cherry-pick 保留了直接签出似乎无法做到的原始提交消息。）然后我们创建子树，我们希望将所有文件从 repo B 中放入其中。然后我们必须移动引入的所有文件樱桃采摘到子树。在上面的示例中，只有一个README文件要移动。然后我们提交我们的 B-repo 根提交，同时，我们还保留原始提交的时间戳。
现在，我们将B/master在新创建的new_b_root. 我们称新分支b：
git checkout -b b B/master
git rebase -s recursive -Xsubtree=path/to/b-files/ new_b_root
现在，我们将b分支合并到A/master：
git checkout master
git merge --allow-unrelated-histories --no-commit b
git commit -m 'Merge repo B into repo A.'
最后，您可以删除B远程和临时分支：
git remote remove B
git branch -D new_b_root b
最终的图形将具有如下结构：
于 2018-05-05T16:44:28.947 回答
7
我知道事情已经过去很久了，但我对在这里找到的其他答案不满意，所以我写了这个：
me=$(basename $0)
TMP=$(mktemp -d /tmp/$me.XXXXXXXX)
echo
echo "building new repo in $TMP"
echo
sleep 1
set -e
cd $TMP
mkdir new-repo
cd new-repo
git init
cd ..
x=0
while [ -n "$1" ]; do
repo="$1"; shift
git clone "$repo"
dirname=$(basename $repo | sed -e 's/\s/-/g')
if [[ $dirname =~ ^git:.*\.git$ ]]; then
dirname=$(echo $dirname | sed s/.git$//)
fi
cd $dirname
git remote rm origin
git filter-branch --tree-filter \
"(mkdir -p $dirname; find . -maxdepth 1 ! -name . ! -name .git ! -name $dirname -exec mv {} $dirname/ \;)"
cd ..
cd new-repo
git pull --no-commit ../$dirname
[ $x -gt 0 ] && git commit -m "merge made by $me"
cd ..
x=$(( x + 1 ))
done
于 2012-05-07T13:38:36.190 回答
7
如果您试图简单地将两个存储库粘合在一起，则子模块和子树合并是错误的工具，因为它们不会保留所有文件历史记录（正如人们在其他答案中所指出的那样）。有关执行此操作的简单正确方法，请参见此处的答案。
于 2013-01-23T00:08:25.180 回答
6
我遇到了类似的挑战，但就我而言，我们在 repo A 中开发了一个版本的代码库，然后将其克隆到新的 repo 中，repo B，用于新版本的产品。在修复了 repo A 中的一些错误后，我们需要将更改 FI 到 repo B 中。最终执行以下操作：
- 将遥控器添加到指向 repo A 的 repo B (git remote add...)
- 拉出当前分支（我们没有使用 master 进行错误修复）（git pull remoteForRepoA bugFixBranch）
- 将合并推送到 github
工作了一个款待:)
于 2011-11-18T19:36:17.760 回答
6
合并 2 个仓库
git clone ssh://<project-repo> project1
cd project1
git remote add -f project2 project2
git merge --allow-unrelated-histories project2/master
git remote rm project2
delete the ref to avoid errors
git update-ref -d refs/remotes/project2/master
于 2017-08-14T13:36:05.253 回答
5
类似于@Smar，但使用文件系统路径，在 PRIMARY 和 SECONDARY 中设置：
PRIMARY=~/Code/project1
SECONDARY=~/Code/project2
cd $PRIMARY
git remote add test $SECONDARY && git fetch test
git merge test/master
然后你手动合并。
（改编自Anar Manafov 的帖子）
于 2011-08-12T15:15:48.213 回答
4
当您想在一次提交中合并三个或更多项目时，请按照其他答案 ( remote add -f, merge) 中所述的步骤进行操作。然后，（软）将索引重置为旧头（没有发生合并）。添加所有文件 ( git add -A) 并提交它们（消息“将项目 A、B、C 和 D 合并到一个项目中）。这现在是 master 的 commit-id。
现在，.git/info/grafts使用以下内容创建：
<commit-id of master> <list of commit ids of all parents>
运行git filter-branch -- head^..head head^2..head head^3..head。如果您有超过三个分支，只需添加与分支一样多head^n..head的数量。要更新标签，请附加--tag-name-filter cat. 不要总是添加它，因为这可能会导致重写某些提交。有关详细信息，请参见filter-branch 的手册页，搜索“grafts”。
现在，您的最后一次提交关联了正确的父级。
于 2013-05-09T14:46:21.640 回答
4
要在 B 中合并 A：
1）在项目A中
git fast-export --all --date-order > /tmp/ProjectAExport
2）在项目B中
git checkout -b projectA
git fast-import --force < /tmp/ProjectAExport
在此分支中执行您需要执行的所有操作并提交它们。
C）然后回到master和两个分支之间的经典合并：
git checkout master
git merge projectA
于 2015-07-28T16:47:33.723 回答
3
我稍微手动合并项目，这样我就可以避免处理合并冲突。
首先，从其他项目中复制您想要的文件。
cp -R myotherproject newdirectory
git add newdirectory
历史的下一个拉动
git fetch path_or_url_to_other_repo
告诉 git 合并到最后获取的东西的历史中
echo 'FETCH_HEAD' > .git/MERGE_HEAD
现在提交但是你通常会提交
git commit
于 2018-02-15T17:38:07.047 回答
2
此功能将远程仓库克隆到本地仓库目录，合并后所有提交将被保存，git log将显示原始提交和正确的路径：
function git-add-repo
{
repo="$1"
dir="$(echo "$2" | sed 's/\/$//')"
path="$(pwd)"
tmp="$(mktemp -d)"
remote="$(echo "$tmp" | sed 's/\///g'| sed 's/\./_/g')"
git clone "$repo" "$tmp"
cd "$tmp"
git filter-branch --index-filter '
git ls-files -s |
sed "s,\t,&'"$dir"'/," |
GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
' HEAD
cd "$path"
git remote add -f "$remote" "file://$tmp/.git"
git pull "$remote/master"
git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
git remote remove "$remote"
rm -rf "$tmp"
}
如何使用：
cd current/package
git-add-repo https://github.com/example/example dir/to/save
如果进行一些更改，您甚至可以将合并 repo 的文件/目录移动到不同的路径中，例如：
repo="https://github.com/example/example"
path="$(pwd)"
tmp="$(mktemp -d)"
remote="$(echo "$tmp" | sed 's/\///g' | sed 's/\./_/g')"
git clone "$repo" "$tmp"
cd "$tmp"
GIT_ADD_STORED=""
function git-mv-store
{
from="$(echo "$1" | sed 's/\./\\./')"
to="$(echo "$2" | sed 's/\./\\./')"
GIT_ADD_STORED+='s,\t'"$from"',\t'"$to"',;'
}
# NOTICE! This paths used for example! Use yours instead!
git-mv-store 'public/index.php' 'public/admin.php'
git-mv-store 'public/data' 'public/x/_data'
git-mv-store 'public/.htaccess' '.htaccess'
git-mv-store 'core/config' 'config/config'
git-mv-store 'core/defines.php' 'defines/defines.php'
git-mv-store 'README.md' 'doc/README.md'
git-mv-store '.gitignore' 'unneeded/.gitignore'
git filter-branch --index-filter '
git ls-files -s |
sed "'"$GIT_ADD_STORED"'" |
GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
' HEAD
GIT_ADD_STORED=""
cd "$path"
git remote add -f "$remote" "file://$tmp/.git"
git pull "$remote/master"
git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
git remote remove "$remote"
rm -rf "$tmp"
注意
Paths 替换 via sed，因此请确保它在合并后移动到正确的路径中。
该--allow-unrelated-histories参数仅在 git >= 2.9 后才存在。
于 2017-04-11T08:35:05.860 回答
2
我今天必须按如下方式解决它：项目 A 在 bitbucket 中，项目 B 在代码提交中 .. 两者都是相同的项目，但必须合并从 A 到 B 的更改。（诀窍是在 Project 中创建同名分支A，与项目B相同）
- git checkout 项目 A
- git远程删除原点
- git remote add origin 项目 B
- git结帐分支
- 混帐添加 *
- git commit -m "我们已经移动了代码"
- git 推送
于 2021-01-13T03:10:44.557 回答
1
给定命令是我建议的最佳解决方案。
git subtree add --prefix=MY_PROJECT git://github.com/project/my_project.git master
于 2015-11-24T05:39:42.777 回答
1
https://github.com/hraban/tomono再次提到基于脚本的解决方案。
我不是作者，但使用它并且它完成了工作。
一个积极的方面是您将所有分支和所有历史记录到最终回购中。对于我的回购（回购中没有重复的文件夹 - 实际上，它们来自 tfs2git 迁移）没有冲突，一切都自动运行。
它主要用于（见名称）创建 monorepos。
对于 Windows 用户： git bash 可以执行 .sh 文件。它带有标准的 git 安装。
于 2020-09-19T10:03:34.470 回答
1
除了使用remote add-> fetch->merge策略的所有答案之外：如果您想保留来自其他存储库的标签但又不想将它们全部溢出到一个公共命名空间中（并且可能会发生冲突），您可能需要更改 fetch 命令一点点：
git fetch --no-tags other_repo
git fetch --no-tags other_repo 'refs/tags/*:refs/tags/other_repo/*'
第一个命令像往常一样获取所有分支，但省略了附加到提交的标签，第二个命令也省略了通常的标签获取机制（git help fetch更多），并获取所有将它们映射X到other_repo/X使用 git 的 refspec 功能的标签。
引用（分支、标签）只是 git 中的文件，您可以使用目录进行命名空间。上面的两个命令将按原样保留第一个存储库中的标签，而另一个存储库中的标签将带有前缀other_repo/
操作后最好将另一个遥控器取下，以免您不小心按正常方式获取标签并弄乱。
于 2021-04-07T16:12:00.983 回答
1
谷歌有一个 Copybara 工具用于更复杂的用例 - https://github.com/google/copybara
于 2021-12-15T16:18:55.380 回答
0
我想将一个小项目移动到一个较大项目的子目录中。由于我的小项目没有很多提交，所以我使用了git format-patch --output-directory /path/to/patch-dir. 然后在更大的项目中，我使用了git am --directory=dir/in/project /path/to/patch-dir/*.
与过滤器分支相比，这感觉不那么可怕并且更清洁。当然，它可能并不适用于所有情况。
于 2018-12-14T21:57:32.953 回答