litvc 1.0.1

Lit - The agentic-first distributed version control system. A complete Git replacement designed for AI agents first and humans second.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::core::{find_repo_root, read_ref, update_head, write_ref, Object, ObjectHash, Tree};
use crate::response::CheckoutResponse;
use crate::storage::{Index, ObjectStore};
use std::fs;
use std::path::Path;

pub fn execute(
    target: String,
    create_new: bool,
) -> Result<CheckoutResponse, crate::errors::LitError> {
    let repo_root = find_repo_root()?;

    if create_new {
        use crate::core::read_head;
        let head_hash = read_head(&repo_root)?;
        write_ref(&repo_root, &format!("heads/{}", target), &head_hash)?;
        update_head(&repo_root, &target)?;
        checkout_commit(&repo_root, &ObjectHash::from_hex(head_hash))?;
        Ok(CheckoutResponse {
            target,
            is_new_branch: true,
            is_detached: false,
        })
    } else if let Ok(commit_hash) = read_ref(&repo_root, &format!("heads/{}", target)) {
        update_head(&repo_root, &target)?;
        checkout_commit(&repo_root, &ObjectHash::from_hex(commit_hash))?;
        Ok(CheckoutResponse {
            target,
            is_new_branch: false,
            is_detached: false,
        })
    } else {
        let hash = ObjectHash::from_hex(target.clone());
        checkout_commit(&repo_root, &hash)?;
        use crate::core::set_head_detached;
        set_head_detached(&repo_root, &target)?;
        Ok(CheckoutResponse {
            target,
            is_new_branch: false,
            is_detached: true,
        })
    }
}

fn checkout_commit(
    repo_root: &Path,
    commit_hash: &ObjectHash,
) -> Result<(), crate::errors::LitError> {
    let store = ObjectStore::new(repo_root);

    // Read commit
    let commit = match store.read(commit_hash)? {
        Object::Commit(c) => c,
        _ => return Err("Not a commit".into()),
    };

    // Read tree
    let tree = match store.read(&commit.tree)? {
        Object::Tree(t) => t,
        _ => return Err("Not a tree".into()),
    };

    // Update working directory
    checkout_tree(repo_root, &tree, &store, "")?;

    // Update index
    let mut index = Index::new();
    for entry in &tree.entries {
        let path = if entry.name.is_empty() {
            continue;
        } else {
            entry.name.clone()
        };

        index.add(path, entry.hash.to_string(), entry.mode.clone());
    }
    index.save(repo_root)?;

    Ok(())
}

fn checkout_tree(
    repo_root: &Path,
    tree: &Tree,
    store: &ObjectStore,
    prefix: &str,
) -> Result<(), crate::errors::LitError> {
    for entry in &tree.entries {
        let path = if prefix.is_empty() {
            entry.name.clone()
        } else {
            format!("{}/{}", prefix, entry.name)
        };

        let full_path = repo_root.join(&path);

        match entry.object_type.as_str() {
            "blob" => {
                // Write file
                let blob = match store.read(&entry.hash)? {
                    Object::Blob(b) => b,
                    _ => return Err("Expected blob".into()),
                };

                if let Some(parent) = full_path.parent() {
                    fs::create_dir_all(parent)
                        .map_err(|e| format!("Failed to create directory: {}", e))?;
                }

                fs::write(&full_path, &blob.content)
                    .map_err(|e| format!("Failed to write file: {}", e))?;
            }
            "tree" => {
                // Recursively checkout subtree
                let subtree = match store.read(&entry.hash)? {
                    Object::Tree(t) => t,
                    _ => return Err("Expected tree".into()),
                };

                checkout_tree(repo_root, &subtree, store, &path)?;
            }
            _ => {}
        }
    }

    Ok(())
}