Add the simple scripts I used to do a merge with content conflicts.

They sure as hell aren't perfect, but they allow you to do:

./git-pull-script {other-git-directory}

to do the initial merge, and if that had content clashes, you do

merge-cache ./git-merge-one-file-script -a

which tries to auto-merge. When/if the auto-merge fails, it will
leave the last file in your working directory, and you can edit
it and then when you're happy you can do "update-cache filename"
on it. Re-do the merge-cache thing until there are no files left
to be merged, and now you can write the tree and commit:

write-tree
commit-tree .... -p $(cat .git/HEAD) -p $(cat .git/MERGE_HEAD)

and you're done.

diff --git a/git-merge-one-file-script b/git-merge-one-file-script
new file mode 100755 (executable)
index 0000000..26dbe63
--- /dev/null
+++ b/git-merge-one-file-script
@@ -0,0 +1,35 @@
+#!/bin/sh
+#
+# This is the git merge script, called with
+#
+#   $1 - original file (or empty string)
+#   $2 - file in branch1 (or empty string)
+#   $3 - file in branch2 (or empty string)
+#   $4 - pathname in repository
+#
+#
+# Case 1: file removed in both
+#
+if [ -z "$2$3" ]; then
+       rm -- "$4"
+       update-cache --remove -- "$4"
+       exit 0
+fi
+#
+# Case 2: file exists in just one
+#
+if [ "$2$3" == "$3$2" ]; then
+       cat "$2$3" > "$4"
+       update-cache --add -- "$4"
+       exit 0
+fi
+#
+# Case 3: file exists in both
+#
+src="$1"
+if [ -z "$1" ]; then
+       src=/dev/null
+fi     
+echo "Auto-merging $4"
+cp "$3" "$4"
+merge "$4" "$src" "$2" && update-cache --add -- "$4"

diff --git a/git-prune-script b/git-prune-script
new file mode 100755 (executable)
index 0000000..d0f19f1
--- /dev/null
+++ b/git-prune-script
@@ -0,0 +1,2 @@
+#!/bin/sh
+fsck-cache --unreachable $(cat .git/HEAD ) | grep unreachable | cut -d' ' -f3 | sed 's:^\(..\):.git/objects/\1/:' | xargs rm

diff --git a/git-pull-script b/git-pull-script
new file mode 100755 (executable)
index 0000000..b04a9be
--- /dev/null
+++ b/git-pull-script
@@ -0,0 +1,46 @@
+#!/bin/sh
+#
+# use "$1" or something in a real script, this 
+# just hard-codes it.
+#
+merge_repo=$1
+
+echo "Getting object database"
+rsync -avz --ignore-existing $merge_repo/ .git/
+
+echo "Getting remote head"
+rsync -avz $merge_repo/HEAD .git/MERGE_HEAD
+
+head=$(cat .git/HEAD)
+merge_head=$(cat .git/MERGE_HEAD)
+common=$(merge-base $head $merge_head)
+if [ -z "$common" ]; then
+       echo "Unable to find common commit between" $merge_head $head
+       exit 1
+fi
+
+# Get the trees associated with those commits
+common_tree=$(cat-file commit $common | sed 's/tree //;q')
+head_tree=$(cat-file commit $head | sed 's/tree //;q')
+merge_tree=$(cat-file commit $merge_head | sed 's/tree //;q')
+
+if [ "$common" == "$merge_head" ]; then
+       echo "Already up-to-date. Yeeah!"
+       exit 0
+fi
+if [ "$common" == "$head" ]; then
+       echo "Updating from $head to $merge_head."
+       echo "Destroying all noncommitted data!"
+       echo "Kill me within 3 seconds.."
+       sleep 3
+       read-tree $merge_tree && checkout-cache -f -a
+       echo $merge_head > .git/HEAD
+       exit 0
+fi
+echo "Trying to merge $merge_head into $head"
+read-tree -m $common_tree $head_tree $merge_tree
+result_tree=$(write-tree) || exit 1
+result_commit=$(echo "Merge $merge_repo" | commit-tree $result_tree -p $head -p $merge_head)
+echo "Committed merge $result_commit"
+echo $result_commit > .git/HEAD
+read-tree $result_tree && checkout-cache -f -a