thor-wt 0.2.0

Worktree workflow commands for Thor
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

use thor_core::{find_repo, list_worktrees};
use std::path::PathBuf;

/// What the user wants to navigate to.
pub enum GoQuery {
    /// Fuzzy substring match on branch name.
    Fuzzy(String),
    /// Jump by 1-based index in the worktree list.
    Index(usize),
    /// Return to the previous worktree.
    Previous,
}

/// Result of a go operation.
pub enum GoResult {
    Found { path: PathBuf, branch: String },
    NotFound(String),
    Ambiguous(Vec<String>),
}

/// Persist the current worktree path for `go -`.
pub fn save_last_worktree(path: &std::path::Path) {
    if let Some(data_dir) = dirs::data_dir() {
        let thor_dir = data_dir.join("thor");
        let _ = std::fs::create_dir_all(&thor_dir);
        let _ = std::fs::write(thor_dir.join("last_worktree"), path.display().to_string());
    }
}

fn load_last_worktree() -> Option<PathBuf> {
    let data_dir = dirs::data_dir()?;
    let path_str = std::fs::read_to_string(data_dir.join("thor").join("last_worktree")).ok()?;
    let path = PathBuf::from(path_str.trim());
    if path.is_dir() { Some(path) } else { None }
}

/// Navigate to a worktree by fuzzy match, index, or previous.
pub async fn go(query: &GoQuery) -> anyhow::Result<GoResult> {
    let repo = find_repo()?;
    let worktrees = list_worktrees(&repo).await?;

    match query {
        GoQuery::Previous => {
            match load_last_worktree() {
                Some(saved) => {
                    // Match saved path against worktree roots (cwd may be a subdirectory)
                    match worktrees.iter().find(|wt| saved.starts_with(&wt.path)) {
                        Some(wt) => Ok(GoResult::Found {
                            path: wt.path.clone(),
                            branch: wt.display_name(),
                        }),
                        None => Ok(GoResult::Found { path: saved, branch: "unknown".to_string() }),
                    }
                }
                None => Ok(GoResult::NotFound("No previous worktree".to_string())),
            }
        }
        GoQuery::Index(idx) => {
            match worktrees.get(idx.saturating_sub(1)) {
                Some(wt) => Ok(GoResult::Found {
                    path: wt.path.clone(),
                    branch: wt.display_name(),
                }),
                None => Ok(GoResult::NotFound(format!("Index {} out of range (1-{})", idx, worktrees.len()))),
            }
        }
        GoQuery::Fuzzy(query) => {
            let query_lower = query.to_lowercase();

            // Try exact match first
            if let Some(wt) = worktrees.iter().find(|wt| {
                wt.branch.as_ref().map(|b| b == query).unwrap_or(false)
            }) {
                return Ok(GoResult::Found {
                    path: wt.path.clone(),
                    branch: wt.display_name(),
                });
            }

            // Try substring match (case-insensitive)
            let matches: Vec<_> = worktrees.iter()
                .filter(|wt| {
                    wt.branch.as_ref()
                        .map(|b| b.to_lowercase().contains(&query_lower))
                        .unwrap_or(false)
                })
                .collect();

            match matches.len() {
                0 => Ok(GoResult::NotFound(format!("No worktree matching '{}'", query))),
                1 => Ok(GoResult::Found {
                    path: matches[0].path.clone(),
                    branch: matches[0].display_name(),
                }),
                _ => Ok(GoResult::Ambiguous(
                    matches.iter().map(|wt| wt.display_name()).collect()
                )),
            }
        }
    }
}