limb 0.1.0

A focused CLI for git worktree management
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Implements `limb migrate`. Converts plain clone → bare-clone layout.

use std::path::Path;

use anyhow::{Context as _, Result};

use crate::cancel::Cancel;

use crate::cli::MigrateArgs;
use crate::context::Context;
use crate::git;

/// Runs `limb migrate`.
///
/// Converts a plain `.git`-based clone into the bare-clone + worktrees
/// layout that `limb` is designed around: the original `.git` directory
/// becomes `.bare/`, and the worktree content moves into a subdirectory
/// named after the checked-out branch.
///
/// Refuses to run on dirty trees, detached HEAD, or if a `.bare` already
/// exists. The original tree is renamed to `.{repo}-limb-old/` so the
/// operation is reversible by hand.
///
/// # Errors
///
/// Returns an error if the repo is dirty, detached, already bare, or if
/// any of the required filesystem moves fail.
pub fn run(ctx: &Context, args: &MigrateArgs) -> Result<()> {
    let repo = match &args.repo {
        Some(p) => p.clone(),
        None => ctx.repo()?,
    };
    migrate(&repo, args.dry_run, &ctx.cancel)
}

fn migrate(repo: &Path, dry_run: bool, cancel: &Cancel) -> Result<()> {
    let repo = repo
        .canonicalize()
        .with_context(|| format!("canonicalize {}", repo.display()))?;
    if !repo.is_dir() {
        anyhow::bail!("not a directory: {}", repo.display());
    }

    let git_dir = repo.join(".git");
    if repo.join(".bare").is_dir() {
        anyhow::bail!("{} already has .bare/; nothing to do", repo.display());
    }
    if !git_dir.is_dir() {
        anyhow::bail!(
            "{} does not look like a plain git clone (no .git directory); \
             try: `limb migrate` only works on repos you cloned directly, not worktrees",
            repo.display()
        );
    }

    let head_branch = git::capture(&repo, &["rev-parse", "--abbrev-ref", "HEAD"])?
        .trim()
        .to_string();
    if head_branch.is_empty() || head_branch == "HEAD" {
        anyhow::bail!("repo is in detached HEAD; check out a named branch first");
    }

    let dirty = git::capture(&repo, &["status", "--porcelain=v1"])?;
    if !dirty.trim().is_empty() {
        anyhow::bail!("working tree has uncommitted changes; commit or stash them first");
    }

    let parent = repo
        .parent()
        .context("repo has no parent directory")?
        .to_path_buf();
    let repo_name = repo
        .file_name()
        .and_then(|n| n.to_str())
        .context("repo has no basename")?
        .to_string();
    let new_root = parent.join(&repo_name);
    let bare_dir = new_root.join(".bare");
    let worktree_dir = new_root.join(&head_branch);
    let staging_dir = parent.join(format!(".{repo_name}-limb-migrate"));

    eprintln!("migrate plan:");
    eprintln!("  from: {}", repo.display());
    eprintln!("  bare:     {}", bare_dir.display());
    eprintln!(
        "  worktree: {}  (branch: {head_branch})",
        worktree_dir.display()
    );
    if dry_run {
        eprintln!("\ndry run; no changes made");
        return Ok(());
    }

    std::fs::create_dir_all(&staging_dir)
        .with_context(|| format!("create staging dir {}", staging_dir.display()))?;

    if let Err(e) = cancel.check() {
        let _ = std::fs::remove_dir_all(&staging_dir);
        return Err(e);
    }

    let staged_bare = staging_dir.join(".bare");
    std::fs::rename(&git_dir, &staged_bare)
        .with_context(|| format!("move {} → {}", git_dir.display(), staged_bare.display()))?;

    git::run(&staged_bare, &["config", "--unset-all", "core.worktree"]).ok();
    git::run(&staged_bare, &["config", "core.bare", "true"])?;

    let staged_worktree = staging_dir.join(&head_branch);
    let staged_worktree_parent = staged_worktree
        .parent()
        .with_context(|| format!("no parent for {}", staged_worktree.display()))?;
    std::fs::create_dir_all(staged_worktree_parent)?;
    move_contents(&repo, &staged_worktree)?;

    std::fs::rename(&repo, parent.join(format!(".{repo_name}-limb-old")))
        .with_context(|| format!("rename old repo dir {}", repo.display()))?;
    std::fs::rename(&staging_dir, &new_root)
        .with_context(|| format!("rename staging → {}", new_root.display()))?;

    git::run(
        &new_root.join(".bare"),
        &[
            "worktree",
            "add",
            worktree_dir.to_string_lossy().as_ref(),
            &head_branch,
        ],
    )
    .ok();

    let old = parent.join(format!(".{repo_name}-limb-old"));
    if old.exists() {
        let _ = std::fs::remove_dir_all(&old);
    }

    eprintln!("\nmigrated: {} (branch {head_branch})", new_root.display());
    Ok(())
}

fn move_contents(src: &Path, dst: &Path) -> Result<()> {
    std::fs::create_dir_all(dst)?;
    for entry in std::fs::read_dir(src)? {
        let entry = entry?;
        let name = entry.file_name();
        if name == ".git" || name == ".bare" {
            continue;
        }
        let to = dst.join(&name);
        std::fs::rename(entry.path(), &to)
            .with_context(|| format!("move {} → {}", entry.path().display(), to.display()))?;
    }
    Ok(())
}