从零构建 Git 分布式版本控制系统：对象模型、Packfile 与网络协议的深度工程实践

Git 不仅仅是版本控制的代名词，它是过去二十年软件工程基础设施演化的一个缩影。理解 Git 内核不仅能让你游刃有余地处理复杂版本问题，更能让你掌握分布式系统设计的核心思想——内容寻址、无信任拓扑、增量传输与最终一致。本文将从零开始，深入剖析 Git 的四个对象模型、Packfile 压缩、引用系统与网络传输协议，并最终用 Rust 实现一个简化但功能完备的 Git 核心引擎。

一、Git 的本质：有向无环图与内容寻址

Git 常被误解为"增量差异"系统，实际上它是一个内容寻址的键值存储，其数据结构是一个有向无环图（DAG）。每一个修改、每一次提交，都是图中的一个节点；节点之间的边是父引用。

这个设计的关键在于：数据永远不可变。当文件被修改时，Git 不会在原地更新它——它创建一个新的 Blob 对象，获得一个新的 SHA-1 哈希。旧的对象继续存在，被引用的历史继续有效。这使得 Git 天然具备：

• 完整性保证：每个对象的哈希依赖于内容和所有子引用，任何篡改都会导致哈希不匹配
• 去重：相同内容的文件只存储一次
• 高效快照：整个工作区的一棵树可以被一个 Tree 对象完整描述

1.1 四种对象类型

Git 的四种核心对象构成了其存储的基石：

每种对象在存储前会被格式化为：

<type> <size>\0<content>

然后将这个字符串计算 SHA-1 哈希作为对象的标识。

二、对象存储引擎

2.1 Loose Object 模式

最简单的存储方式是每个对象独立存为一个文件，路径为 .git/objects/ab/cdef...，其中 ab 是 SHA-1 的前两位作为目录，后 38 位作为文件名。

当用户执行 git add 时，Git 的工作流程是：

1. 读取文件内容
2. 构建 Git 内部对象格式 blob \0<size>\0<content>
3. 计算 SHA-1：sha1("blob " + len + "\0" + content)
4. 用 zlib 压缩对象内容
5. 写入 .git/objects/xx/yyyy...

2.2 用 Rust 实现 Object Store

下面是一个完整的 Git 对象存储引擎实现，支持 Blob 的写入和读取：

use sha1::{Sha1, Digest};
use flate2::read::ZlibDecoder;
use flate2::write::ZlibEncoder;
use flate2::Compression;
use std::io::{Read, Write};
use std::path::PathBuf;

#[derive(Debug, Clone)]
pub enum GitObject {
    Blob(Vec<u8>),
    Tree(Vec<TreeEntry>),
    Commit(CommitData),
    Tag(TagData),
}

#[derive(Debug, Clone)]
pub struct TreeEntry {
    pub mode: String,      // "100644" 文件, "100755" 可执行, "040000" 目录
    pub name: String,
    pub sha1: [u8; 20],
}

#[derive(Debug, Clone)]
pub struct CommitData {
    pub tree: [u8; 20],
    pub parents: Vec<[u8; 20]>,
    pub author: String,
    pub committer: String,
    pub message: String,
}

pub struct ObjectStore {
    git_dir: PathBuf,
}

impl ObjectStore {
    pub fn new(git_dir: PathBuf) -> Self {
        Self { git_dir }
    }

    /// 写入对象并返回其 SHA-1 哈希
    pub fn write_object(&self, obj: &GitObject) -> Result<[u8; 20], GitError> {
        let (type_name, raw_data) = match obj {
            GitObject::Blob(content) => {
                let mut data = Vec::new();
                data.extend_from_slice(content);
                ("blob", data)
            }
            GitObject::Tree(entries) => {
                let mut data = Vec::new();
                for entry in entries {
                    data.extend_from_slice(format!("{} {}\0", entry.mode, entry.name).as_bytes());
                    data.extend_from_slice(&entry.sha1);
                }
                ("tree", data)
            }
            GitObject::Commit(commit) => {
                let mut data = Vec::new();
                // tree
                data.extend_from_slice(format!("tree {}\n", hex::encode(&commit.tree)).as_bytes());
                // parents
                for parent in &commit.parents {
                    data.extend_from_slice(format!("parent {}\n", hex::encode(parent)).as_bytes());
                }
                // author & committer
                data.extend_from_slice(format!("author {}\n", commit.author).as_bytes());
                data.extend_from_slice(format!("committer {}\n", commit.committer).as_bytes());
                // empty line + message
                data.push(b'\n');
                data.extend_from_slice(commit.message.as_bytes());
                ("commit", data)
            }
            GitObject::Tag(_) => todo!(),
        };

        // 构建 Git 对象头: "<type> <size>\0"
        let header = format!("{} {}\0", type_name, raw_data.len());
        let mut full_data = Vec::new();
        full_data.extend_from_slice(header.as_bytes());
        full_data.extend_from_slice(&raw_data);

        // 计算 SHA-1
        let mut hasher = Sha1::new();
        hasher.update(&full_data);
        let sha1: [u8; 20] = hasher.finalize().into();

        // zlib 压缩
        let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
        encoder.write_all(&full_data)?;
        let compressed = encoder.finish()?;

        // 写入 .git/objects/xx/yy...
        let hex = hex::encode(&sha1);
        let (dir, file) = hex.split_at(2);
        let obj_dir = self.git_dir.join("objects").join(dir);
        std::fs::create_dir_all(&obj_dir)?;
        std::fs::write(obj_dir.join(file), compressed)?;

        Ok(sha1)
    }

    /// 通过 SHA-1 哈希读取对象
    pub fn read_object(&self, sha1: &[u8; 20]) -> Result<GitObject, GitError> {
        let hex = hex::encode(sha1);
        let (dir, file) = hex.split_at(2);
        let obj_path = self.git_dir.join("objects").join(dir).join(file);

        let compressed = std::fs::read(obj_path)?;
        let mut decoder = ZlibDecoder::new(&compressed[..]);
        let mut raw = Vec::new();
        decoder.read_to_end(&mut raw)?;

        // 解析 "<type> <size>\0<content>"
        let null_pos = raw.iter().position(|&b| b == 0).ok_or(GitError::InvalidFormat)?;
        let header = String::from_utf8_lossy(&raw[..null_pos]);
        let content = &raw[null_pos + 1..];

        let (type_name, _) = header.split_once(' ').ok_or(GitError::InvalidFormat)?;

        match type_name {
            "blob" => Ok(GitObject::Blob(content.to_vec())),
            "tree" => Self::parse_tree(content),
            "commit" => Self::parse_commit(content),
            _ => Err(GitError::UnknownType(type_name.to_string())),
        }
    }

    fn parse_tree(data: &[u8]) -> Result<GitObject, GitError> {
        let mut entries = Vec::new();
        let mut i = 0;

        while i < data.len() {
            // mode name\0sha1(20 bytes)
            let space = data[i..].iter().position(|&b| b == b' ').ok_or(GitError::InvalidFormat)?;
            let mode = String::from_utf8_lossy(&data[i..i + space]).to_string();
            i += space + 1;

            let null = data[i..].iter().position(|&b| b == 0).ok_or(GitError::InvalidFormat)?;
            let name = String::from_utf8_lossy(&data[i..i + null]).to_string();
            i += null + 1;

            let mut sha1 = [0u8; 20];
            sha1.copy_from_slice(&data[i..i + 20]);
            i += 20;

            entries.push(TreeEntry { mode, name, sha1 });
        }

        Ok(GitObject::Tree(entries))
    }

    fn parse_commit(data: &[u8]) -> Result<GitObject, GitError> {
        let text = String::from_utf8_lossy(data);
        let mut tree = [0u8; 20];
        let mut parents = Vec::new();
        let mut author = String::new();
        let mut committer = String::new();
        let mut message = String::new();
        let mut in_message = false;

        for line in text.lines() {
            if in_message {
                message.push_str(line);
                message.push('\n');
                continue;
            }
            if line.is_empty() {
                in_message = true;
                continue;
            }
            if let Some(rest) = line.strip_prefix("tree ") {
                hex::decode_to_slice(rest, &mut tree)?;
            } else if let Some(rest) = line.strip_prefix("parent ") {
                let mut p = [0u8; 20];
                hex::decode_to_slice(rest, &mut p)?;
                parents.push(p);
            } else if let Some(rest) = line.strip_prefix("author ") {
                author = rest.to_string();
            } else if let Some(rest) = line.strip_prefix("committer ") {
                committer = rest.to_string();
            }
        }

        Ok(GitObject::Commit(CommitData {
            tree, parents, author, committer, message,
        }))
    }
}

三、Packfile：高压缩率的打包格式

随着项目历史增长，Loose Object 模式会导致大量小文件，I/O 效率低下。Git 引入了 Packfile——将所有对象打包到一个文件中，配合索引文件实现快速随机访问。

3.1 Packfile 文件结构

+--------+----------------------------------+
| Header | 4 bytes: "PACK"                  |
|        | 4 bytes: version (2)             |
|        | 4 bytes: number of objects       |
+--------+----------------------------------+
| Data   | Object entries (delta or full)   |
+--------+----------------------------------+
| Footer | 20 bytes SHA-1 of all above data |
+-------------------------------------------+

3.2 Delta 压缩算法

Packfile 的核心是 xdelta 差异压缩。Git 选择一个对象作为 base，后续相似对象只存储 diff。Delta 对象有两种类型：

• OFS_DELTA：base 对象在同一 packfile 中的偏移位置
• REF_DELTA：base 对象的 SHA-1（跨 packfile 引用）

Delta 指令使用一个简单的指令集：

Instruction 0: Copy from base (offset, size)
Instruction 1: Insert new data (length, data)

3.3 Packfile 索引（.idx）

为了在打包文件中快速定位对象，Git 生成 .idx 索引文件，包含：

• 对象 SHA-1 的有序列表
• 每个对象在 packfile 中的偏移
• CRC32 校验和
• 可选的分层（大对象单独标记）

有了索引，查询对象的时间复杂度从 O(N) 降低到 O(log N)。

四、引用系统：从 .git/refs 到 Reflog

对象通过 SHA-1 哈希是不可读的，Git 通过"引用"给它们赋予人类友好的名称：

.git/refs/heads/main          → 指向最新的 commit SHA-1
.git/refs/tags/v1.0.0        → 指向 annotated tag
.git/refs/remotes/origin/main → 远程跟踪分支
.git/HEAD                    → 当前分支的符号引用（ref: refs/heads/main）

4.1 Packed Refs

为了优化上万引用的性能，Git 将所有引用装入 .git/packed-refs 文件（扁平文件 + SHA-1），避免遍历目录。

当引用更新时，Git 优先查找 packed-refs，然后在 refs/heads 下搜索。这种设计确保即使有百万个分支也不会因为文件系统操作而卡顿。

4.2 Reflog：引用的时光机

Reflog 记录了每个引用在过去一段时间内的所有状态变化：

0000000... abc1234 HEAD@{0}: commit: Add feature X
abc1234... def5678 HEAD@{1}: commit: Fix bug Y

Reflog 是 Git 最重要的安全网——即使你误删了分支、执行了变基，Reflog 都会记录之前的 commit，让你有 90 天的窗口来恢复。

五、网络传输协议

Git 的网络协议设计极其精巧，支持 dumb HTTP（静态文件传输）和 smart protocol（带协商的双向通信）。

5.1 核心思路：Want-Have Negotiation

Git fetch/push 的核心是 want-have 协商算法，避免传输不需要的数据：

1. Client 发送 want <SHA-1>... — 我想要的 commit
2. Server 回复 have <SHA-1>... — 我已经有的 commit
3. Client 计算缺失对象范围，回复 done 或更多 have
4. Server 根据最终协商结果，生成精确的最小 packfile

5.2 Protocol v2 的改进

Git 2.18 引入 Protocol v2，解决了 v0/v1 的命令歧义问题。v2 使用独立的命令帧：

> command=ls-refs
> command=fetch

取消了 v0 中 ACK/NAK 这种混杂的交错帧，让协议设计更清晰。

5.3 实现一个 Rust 仓库克隆器

下面是一个简化的 Git 客户端，能够解析服务端 Advertisement、协商并下载 packfile：

use std::io::{BufRead, BufReader, Read, Write};
use std::net::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

pub struct GitRemoteClient {
    url: String,
}

impl GitRemoteClient {
    /// 执行 ls-refs 命令，获取服务端所有引用
    pub async fn ls_refs(&self) -> Result<Vec<RefAdvertisement>, GitError> {
        let stream = TcpStream::connect(&self.url)?;
        let (mut reader, mut writer) = (BufReader::new(stream.try_clone()?), stream);

        // 发送 protocol v2 的 ls-refs 命令
        let pkt = Self::pkt_line(b"command=ls-refs\n");
        let delim = Self::pkt_line(b"");
        let ref_prefix = Self::pkt_line(b"ref-prefix HEAD\n");

        writer.write_all(&pkt)?;
        writer.write_all(&delim)?;
        writer.write_all(&ref_prefix)?;
        writer.write_all(Self::pkt_flush())?;

        // 解析响应
        let mut refs = Vec::new();
        loop {
            let line = Self::read_pkt_line(&mut reader)?;
            if line.is_empty() { break; }

            // 响应格式: "SHA-1 refname"
            let parts: Vec<&str> = line.splitn(2, ' ').collect();
            if parts.len() == 2 {
                let mut sha1 = [0u8; 20];
                hex::decode_to_slice(parts[0], &mut sha1)?;
                refs.push(RefAdvertisement {
                    sha1,
                    name: parts[1].to_string(),
                });
            }
        }

        Ok(refs)
    }

    /// 通过 fetch 命令获取缺失对象
    pub async fn fetch(&self, wants: &[[u8; 20]], have: &[[u8; 8]]) -> Result<Vec<u8>, GitError> {
        let stream = TcpStream::connect(&self.url)?;
        let (mut reader, mut writer) = (BufReader::new(stream.try_clone()?), stream);

        // 第一次请求：命令头
        let cmd = Self::pkt_line(b"command=fetch\n");
        let delim = Self::pkt_line(b"");
        let thin_pack = Self::pkt_line(b"thin-pack\n");
        let no_progress = Self::pkt_line(b"no-progress\n");

        writer.write_all(&cmd)?;
        writer.write_all(&delim)?;
        writer.write_all(&thin_pack)?;
        writer.write_all(&no_progress)?;

        // 发送 want 列表
        for w in wants {
            let line = format!("want {}\n", hex::encode(w));
            writer.write_all(&Self::pkt_line(line.as_bytes()))?;
        }

        // 发送 shallow（简化版，假设没有 shallow）
        writer.write_all(Self::pkt_flush())?;

        // 发送 have 列表（告诉服务端我们已有哪些可以共享 base）
        for h in have {
            let line = format!("have {}\n", hex::encode(h));
            writer.write_all(&Self::pkt_line(line.as_bytes()))?;
        }

        writer.write_all(b"done\n")?;

        // 接收 packfile
        let mut pack_data = Vec::new();
        let header = Self::read_pkt_line(&mut reader)?;

        // 第一行为 "ACK" 或 "NAK"，接着是 packfile PKT 帧
        if header.starts_with("ACK") || header.starts_with("packfile") {
            loop {
                let pkt = Self::read_pkt_line(&mut reader)?;
                if pkt.is_empty() { break; }
                pack_data.extend_from_slice(&pkt);
                pack_data.push(b'\n');
            }
        }

        Ok(pack_data)
    }

    /// Git pkt-line 格式：4 hex length + data
    fn pkt_line(data: &[u8]) -> Vec<u8> {
        let len = data.len() + 4;
        format!("{:04x}", len).into_bytes().into_iter()
            .chain(data.iter().copied())
            .collect()
    }

    fn pkt_flush() -> &'static [u8] {
        b"0000"
    }

    fn read_pkt_line(reader: &mut BufReader<TcpStream>) -> Result<Vec<u8>, GitError> {
        let mut buf = [0u8; 4];
        reader.read_exact(&mut buf)?;
        let len_str = String::from_utf8_lossy(&buf);
        let len = usize::from_str_radix(&len_str, 16)?; // 包括 4 字节长度
        if len == 0 { return Ok(Vec::new()); } // flush pkt

        let mut data = vec![0u8; len - 4];
        reader.read_exact(&mut data)?;
        Ok(data)
    }
}

六、实战：用 Rust 构建 'tiny-git'

将上述所有模块组合起来，我们构建一个简化但能工作的 Git 克隆实现。以下是核心 git init 和 git add + git commit 的完整代码：

use walkdir::WalkDir;

pub struct TinyGit {
    store: ObjectStore,
    index: GitIndex,
}

#[derive(Debug, Default)]
pub struct GitIndex {
    /// 文件路径 -> Blob SHA-1（暂存区）
    entries: HashMap<String, [u8; 20]>,
    /// 文件元数据缓存（ctime, mtime, size, mode）
    stat_cache: HashMap<String, FileStat>,
}

#[derive(Debug, Clone)]
pub struct FileStat {
    pub ctime: u64,
    pub mtime: u64,
    pub size: u32,
    pub mode: u32,
}

impl TinyGit {
    /// 初始化新仓库
    pub fn init(path: &Path) -> Result<Self, GitError> {
        let git_dir = path.join(".tiny-git");
        std::fs::create_dir_all(&git_dir)?;
        std::fs::create_dir_all(git_dir.join("objects"))?;
        std::fs::create_dir_all(git_dir.join("refs").join("heads"))?;
        std::fs::create_dir_all(git_dir.join("refs").join("tags"))?;

        // HEAD 指向 main 分支
        std::fs::write(git_dir.join("HEAD"), "ref: refs/heads/main\n")?;

        // description
        std::fs::write(git_dir.join("description"), "Unnamed repository\n")?;

        // config
        std::fs::write(git_dir.join("config"), "[core]\n\tformatversion = 0\n")?;

        Ok(Self {
            store: ObjectStore::new(git_dir),
            index: GitIndex::default(),
        })
    }

    /// 暂存文件（相当于 git add）
    pub fn add(&mut self, file_path: &Path) -> Result<[u8; 20], GitError> {
        let content = std::fs::read(file_path)?;
        let blob = GitObject::Blob(content);
        let sha1 = self.store.write_object(&blob)?;

        let relative = file_path.strip_prefix(std::env::current_dir()?)
            .unwrap_or(file_path)
            .to_string_lossy()
            .to_string();

        // 检查文件是否已经在暂存区且未改变
        let metadata = std::fs::metadata(file_path)?;
        let stat = FileStat {
            ctime: metadata.created()?.elapsed()?.as_secs() as u64,
            mtime: metadata.modified()?.elapsed()?.as_secs() as u64,
            size: metadata.len() as u32,
            mode: if metadata.permissions().readonly() { 0o100444 } else { 0o100644 },
        };

        self.index.entries.insert(relative.clone(), sha1);
        self.index.stat_cache.insert(relative, stat);

        Ok(sha1)
    }

    /// 从暂存区构建 Tree 对象
    fn build_tree_from_index(&self) -> Result<[u8; 20], GitError> {
        // 将扁平路径列表转换为嵌套 Tree 对象
        let mut root: HashMap<String, Vec<TreeEntry>> = HashMap::new();

        // 按目录分组
        let mut dir_entries: HashMap<String, Vec<TreeEntry>> = HashMap::new();

        // 构建叶子节点
        for (path, &sha1) in &self.index.entries {
            let path_obj = Path::new(path);
            if let Some(parent) = path_obj.parent() {
                let parent_str = parent.to_string_lossy().to_string();
                let name = path_obj.file_name().unwrap().to_string_lossy().to_string();

                dir_entries.entry(parent_str).or_default().push(TreeEntry {
                    mode: "100644".to_string(),
                    name,
                    sha1,
                });
            }
        }

        // 递归构建树（从叶子向上）
        let mut tree_objects: HashMap<String, [u8; 20]> = HashMap::new();
        let mut pending = dir_entries.keys().cloned().collect::<Vec<_>>();

        while let Some(dir) = pending.pop() {
            let mut entries = dir_entries.get(&dir).cloned().unwrap_or_default();

            // 对于每个子目录，注入其对应的 Tree 对象
            for (other_dir, other_tree_sha1) in &tree_objects {
                if let Some(parent) = Path::new(other_dir).parent() {
                    if parent.to_string_lossy() == dir {
                        entries.push(TreeEntry {
                            mode: "040000".to_string(),
                            name: Path::new(other_dir).file_name().unwrap().to_string_lossy().to_string(),
                            sha1: *other_tree_sha1,
                        });
                    }
                }
            }

            entries.sort_by(|a, b| a.name.cmp(&b.name));
            let tree_obj = GitObject::Tree(entries);
            let sha1 = self.store.write_object(&tree_obj)?;
            tree_objects.insert(dir, sha1);
        }

        // 根据根目录内容创建最终 Tree
        if let Some(entries) = dir_entries.get("") {
            let mut top_entries = entries.clone();
            for (dir, sha1) in &tree_objects {
                if !dir.contains('/') {
                    top_entries.push(TreeEntry {
                        mode: "040000".to_string(),
                        name: dir.clone(),
                        sha1: *sha1,
                    });
                }
            }
            top_entries.sort_by(|a, b| a.name.cmp(&b.name));
            let tree = GitObject::Tree(top_entries);
            Ok(self.store.write_object(&tree)?)
        } else {
            // 空仓库
            Ok(self.store.write_object(&GitObject::Tree(vec![]))?)
        }
    }

    /// 创建 commit
    pub fn commit(&self, message: &str, author: &str) -> Result<[u8; 20], GitError> {
        let tree_sha1 = self.build_tree_from_index()?;
        let parent_sha1 = self.read_head()?;

        let commit = CommitData {
            tree: tree_sha1,
            parents: if parent_sha1 == [0u8; 20] { vec![] } else { vec![parent_sha1] },
            author: author.to_string(),
            committer: author.to_string(),
            message: message.to_string(),
        };

        let commit_obj = GitObject::Commit(commit);
        let sha1 = self.store.write_object(&commit_obj)?;

        // 更新 HEAD 引用
        self.update_head(&sha1)?;

        Ok(sha1)
    }

    fn read_head(&self) -> Result<[u8; 20], GitError> {
        let head_path = self.store.git_dir.join("HEAD");
        let content = std::fs::read_to_string(head_path)?;

        if let Some(ref_path) = content.strip_prefix("ref: ") {
            let ref_path = ref_path.trim();
            let ref_file = self.store.git_dir.join(ref_path);
            if ref_file.exists() {
                let hex = std::fs::read_to_string(ref_file)?;
                let mut sha1 = [0u8; 20];
                hex::decode_to_slice(hex.trim(), &mut sha1)?;
                Ok(sha1)
            } else {
                Ok([0u8; 20]) // 空仓库
            }
        } else {
            let mut sha1 = [0u8; 20];
            hex::decode_to_slice(content.trim(), &mut sha1)?;
            Ok(sha1)
        }
    }

    fn update_head(&self, sha1: &[u8; 20]) -> Result<(), GitError> {
        let head_path = self.store.git_dir.join("HEAD");
        let content = std::fs::read_to_string(&head_path)?;

        if let Some(ref_path) = content.strip_prefix("ref: ") {
            let ref_file = self.store.git_dir.join(ref_path.trim());
            if let Some(parent) = ref_file.parent() {
                std::fs::create_dir_all(parent)?;
            }
            std::fs::write(ref_file, format!("{}\n", hex::encode(sha1)))?;
        }
        Ok(())
    }
}

七、Git 在生产工程中的最佳实践

7.1 大文件管理（LFS 替代方案）

原生 Git 对大文件极不友好——每次修改都会完整存储新版本。业界常见方案：

• Git LFS：将大文件替换为指针文件，实际内容存入外部存储
• Git Annex：灵活的元数据管理，支持 archive/track/move 操作
• DVC（Data Version Control）：专为 ML 数据集设计，用哈希引用文件

7.2 Monorepo 的 Git 性能优化

在单一仓库管理数百万文件的 monorepo 场景中：

# 使用稀疏检出避免下载不必要文件
git sparse-checkout init --cone
git sparse-checkout set src/services/api src/lib/common

# 使用部分克隆避免下载所有 blob
git clone --filter=blob:limit=1m https://github.com/org/monorepo.git

7.3 Binary Delta 与 Merge 策略

减少合并冲突的频率，关键是选择合适的 merge 策略：

# .gitattributes
*.lock binary merge=ours    # 锁定文件，始终保留本地
CHANGELOG.md merge=union    # union 合并，保留双方行

7.4 Hooks 自动化

# .git/hooks/pre-commit
#!/bin/sh
# 格式化检查
if ! cargo fmt --check --quiet; then
    echo "Error: 代码未格式化。运行 cargo fmt。"
    exit 1
fi
# 单元测试
if ! cargo test --quiet; then
    echo "Error: 测试失败。"
    exit 1
fi
# Clippy 静态检查
if ! cargo clippy -- -D warnings; then
    echo "Error: Clippy 发现问题。"
    exit 1
fi

八、反思：Git 的设计哲学与局限性

Git 的成功源于几个关键设计决策：内容寻址确保了数据完整性、不可变对象保证了历史安全、简单文件操作替代复杂数据库。仓库可以随意 clone/merge/resolve，无需中心服务器许可。

但 Git 的设计也有代价：

1. 语义丢失：git mv 和 "删除 + 新建" 在底层是相同的。Git 在 blame 时通过内容相似度检测移动/复制，但这只是一个代价昂贵的启发式算法
2. 大文件问题：存储层的 LSM 特性导致大文件的任何修改都会使仓库大小线性增长
3. 历史复杂性：变基、交互式操作、底层命令（plumbing）的学习曲线对新手不友好
4. 二进制差异：对图片、文档、PDF 等二进制文件，Git 无法计算 delta，每个版本都完整存储

理解这些局限性，才能在实际工程中做出正确的技术选型——Git 不是万能的，但对于文本代码的版本管理，它几乎是最优解。

九、总结

从零构建 Git 引擎的过程，是对分布式系统设计、数据压缩、网络协议的一次全面实践。本文带你遍历了：

• 对象存储引擎（Blob / Tree / Commit）
• Loose Object 与 Packfile 的存储演进
• Delta 压缩与索引的协同
• 引用系统与 Reflog 的机制
• 网络传输协议的 Want-Have 协商算法
• 一个完整的 Rust 实现（tiny-git）

Git 的魅力在于：它的核心不到 1000 行代码就能串联起来，但其衍生出的工程生态——从 GitHub Actions 到 monorepo 工具链——重塑了整个软件行业。理解这一层，比盲目使用命令更有价值。