git-claw 0.3.3

Deterministic git worktree orchestration engine for developers and AI agents
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

use git_claw::infra::error::WorktreeError;
use git_claw::infra::worktree::{create_worktree, delete_branch, remove_worktree};
use std::fs;
use std::process::Command;
use tempfile::tempdir;

fn setup_test_git_repo() -> tempfile::TempDir {
    let dir = tempdir().expect("tempdir");
    let path = dir.path();

    let init = Command::new("git")
        .args(["init", "-b", "main"])
        .current_dir(path)
        .output()
        .expect("git init");
    assert!(init.status.success());

    // Configure user name and email for commits in temporary repo
    let _ = Command::new("git")
        .args(["config", "user.name", "Tester"])
        .current_dir(path)
        .output();
    let _ = Command::new("git")
        .args(["config", "user.email", "tester@test.local"])
        .current_dir(path)
        .output();

    // Create an initial commit so main branch exists
    let readme = path.join("README.md");
    fs::write(&readme, "# Test Repo").expect("writes readme");

    let add = Command::new("git")
        .args(["add", "README.md"])
        .current_dir(path)
        .output()
        .expect("git add");
    assert!(add.status.success());

    let commit = Command::new("git")
        .args(["commit", "-m", "Initial commit"])
        .current_dir(path)
        .output()
        .expect("git commit");
    assert!(commit.status.success());

    dir
}

#[test]
fn test_create_and_remove_worktree() {
    let repo_dir = setup_test_git_repo();
    let repo_path = repo_dir.path();
    let worktree_dir = tempdir().expect("worktree parent dir");
    let worktree_path = worktree_dir.path().join("worktree-feat");

    create_worktree(repo_path, &worktree_path, "feature/my-feat", "main")
        .expect("creates worktree");

    assert!(worktree_path.exists());
    assert!(worktree_path.join(".git").exists());

    // Remove worktree
    remove_worktree(repo_path, &worktree_path, false).expect("removes worktree");
    assert!(!worktree_path.exists());

    // Delete branch
    delete_branch(repo_path, "feature/my-feat", false).expect("deletes branch");
}

#[test]
fn test_create_worktree_branch_already_exists() {
    let repo_dir = setup_test_git_repo();
    let repo_path = repo_dir.path();
    let worktree_dir = tempdir().expect("worktree parent dir");
    let worktree_path1 = worktree_dir.path().join("wt1");
    let worktree_path2 = worktree_dir.path().join("wt2");

    create_worktree(repo_path, &worktree_path1, "feature/dup", "main").expect("creates first");

    let err = create_worktree(repo_path, &worktree_path2, "feature/dup", "main").unwrap_err();
    assert!(matches!(err, WorktreeError::BranchAlreadyExists(_)));
    assert!(!worktree_path2.exists());
}