如果您想将来自存储库B分支的文件放在存储库a的子树中，并保留历史记录，请继续阅读。（在下面的示例中，我假设我们希望回购协议B的主分支合并为回购协议A的主分支。）

在回购协议A中，首先执行以下操作以使回购协议B可用：

git remote add B ../B # Add repo B as a new remote.
git fetch B

现在我们在回购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))"

解释：checkout命令的--孤儿选项从A的主分支检出文件，但不创建任何提交。我们可以选择任何提交，因为接下来我们无论如何都要清除所有文件。然后，在尚未提交（-n）的情况下，我们从B的主分支中选择第一个提交。（cherry pick保留了原始的提交消息，而直接签出似乎无法做到这一点。）然后我们创建一个子树，将所有来自repo B的文件放在那里。然后我们必须将cherry stick中引入的所有文件移动到子树中。在上面的示例中，只有一个README文件可以移动。然后我们提交B-repo根提交，同时，我们还保留原始提交的时间戳。

现在，我们将在新创建的new_B_root上创建一个新的B/master分支。我们称新分支为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

最终图形的结构如下：

我稍微手动合并项目，这使我可以避免处理合并冲突。

首先，从另一个项目中复制文件，无论您需要什么。

cp -R myotherproject newdirectory
git add newdirectory

历史上的下一次拉力

git fetch path_or_url_to_other_repo

告诉git在上次获取的历史记录中合并

echo 'FETCH_HEAD' > .git/MERGE_HEAD

现在按您通常的方式提交

git commit

如果您想单独维护项目，子模块方法是很好的。然而，如果您真的想将两个项目合并到同一个存储库中，那么您还有更多的工作要做。

第一件事是使用gitfilter分支将第二个存储库中所有内容的名称重写到您希望它们结束的子目录中。因此，您将使用projb/foo.c和projb/bar.html代替foo.c和bar.html。

然后，您应该能够执行以下操作：

git remote add projb [wherever]
git pull projb

git pull将执行git fetch，然后执行git merge。如果您要拉到的存储库还没有projb/目录，那么应该不会有冲突。

进一步搜索表明，在将gitk合并为git时也做了类似的操作。Junio C Hamano在这里写道：http://www.mail-archive.com/git@vger.kernel.org/msg03395.html

我在这里收集了很多关于StackOverFlow等的信息，并设法编写了一个脚本，为我解决了这个问题。

需要注意的是，它只考虑每个存储库的“开发”分支，并将其合并到一个全新存储库中的单独目录中。

标记和其他分支被忽略-这可能不是您想要的。

该脚本甚至处理功能分支和标记-在新项目中重命名它们，以便您知道它们来自何处。

#!/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

脚本本身有很多注释，应该可以解释它的作用。

我知道事情已经过去很久了，但我对我在这里找到的其他答案并不满意，所以我写了这样一篇文章：

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

在我的例子中，我有一个插件存储库和一个主项目存储库，我想假装我的插件一直是在主项目的插件子目录中开发的。

基本上，我重写了我的插件存储库的历史，使其看起来所有的开发都发生在插件/我的插件子目录中。然后，我将插件的开发历史添加到主项目历史中，并将两棵树合并在一起。由于主项目存储库中没有插件/my插件目录，所以这是一个简单的无冲突合并。生成的存储库包含两个原始项目的所有历史，并且有两个根。

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

长版本

首先，创建我的插件存储库的副本，因为我们将重写这个存储库的历史。

现在，导航到我的插件库的根目录，检查您的主分支（可能是主分支），然后运行以下命令。当然，你应该替换我的插件和插件，无论你的实际名称是什么。

$ 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时，它将对此进行投诉，除非您为filter branch提供-f选项。

至于实际的命令，我没有太多的运气让bash执行我想要的，所以我使用zsh-c来让zsh执行一个命令。首先，我设置了extended_glob选项，这是启用mv命令中的^（…）语法的选项，以及glob_dots选项，它允许我使用glob（^（……））选择点文件（例如.gitignore）。

接下来，我使用mkdir-p命令同时创建插件和plugins/my插件。

最后，我使用zsh“negative glob”特性^（.git |插件）来匹配存储库根目录中的所有文件，但.git和新创建的插件文件夹除外。（此处可能不需要排除.git，但尝试将目录移动到自身是错误的。）

在我的存储库中，初始提交不包含任何文件，因此mv命令在初始提交时返回了一个错误（因为没有可移动的内容）。因此，我添加了一个||true，这样gitfilter分支就不会中止。

-all选项告诉filter-branch重写存储库中所有分支的历史记录，而额外的--则需要告诉git将其解释为分支重写选项列表的一部分，而不是filter-branch本身的一个选项。

现在，导航到您的主项目存储库并检查您要合并到的任何分支。添加我的插件存储库的本地副本（已修改其历史记录）作为主项目的远程副本：

$ 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 history选项不存在。如果您使用的是这些版本中的一个，只需省略选项：2.9.0中还添加了--allow unrelated histories prevent的错误消息。

您不应该有任何合并冲突。如果您这样做了，这可能意味着filter branch命令无法正常工作，或者主项目中已经存在plugins/my插件目录。

确保为任何未来的贡献者输入一个解释性的提交消息，让他们知道如何进行黑客操作来创建一个具有两个根的存储库。

您可以使用上面的gitlog命令可视化新的提交图，它应该有两个根提交。请注意，只有主分支将被合并。这意味着，如果你在其他我的插件分支上有重要的工作要合并到主项目树中，那么在完成这些合并之前，你应该避免删除我的插件远程。如果您不这样做，那么来自这些分支的提交仍将在主项目存储库中，但有些将无法访问，并且容易受到最终垃圾收集的影响。（此外，您必须通过SHA引用它们，因为删除远程会删除其远程跟踪分支。）

可选地，在您合并了我的插件中要保留的所有内容后，您可以使用以下方法删除我的插件远程：

$ git remote remove my-plugin

现在，您可以安全地删除您更改了其历史记录的插件存储库的副本。在我的例子中，在合并完成并推送后，我还向真正的插件存储库添加了一个弃用通知。

---

在Mac OS X El Capitan上测试了git版本2.9.0和zsh版本5.2。您的里程数可能有所不同。

参考文献：

https://git-scm.com/docs/git-filter-branchhttps://unix.stackexchange.com/questions/6393/how-do-you-move-all-files-including-hidden-from-one-directory-to-anotherhttp://www.refining-linux.org/archives/37/ZSH-Gem-2-Extended-globbing-and-expansion/从Git repo清除文件失败，无法创建新备份git，过滤所有分支上的分支