workmux 0.1.179

An opinionated workflow tool that orchestrates git worktrees and tmux
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

//! Sort mode logic for the dashboard agent list.

use crate::state::StateStore;

/// Available sort modes for the agent list
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SortMode {
    /// Sort by agent status importance (Waiting > Done > Working > Stale)
    #[default]
    Priority,
    /// Group agents by project name, then by status within each project
    Project,
    /// Sort by duration since last status change (newest first)
    Recency,
    /// Natural tmux order (by pane_id)
    Natural,
}

impl SortMode {
    /// Cycle to the next sort mode
    pub fn next(self) -> Self {
        match self {
            SortMode::Priority => SortMode::Project,
            SortMode::Project => SortMode::Recency,
            SortMode::Recency => SortMode::Natural,
            SortMode::Natural => SortMode::Priority,
        }
    }

    /// Get the display name for the sort mode
    pub fn label(&self) -> &'static str {
        match self {
            SortMode::Priority => "priority",
            SortMode::Project => "project",
            SortMode::Recency => "recency",
            SortMode::Natural => "natural",
        }
    }

    /// Convert to string for storage.
    fn as_str(&self) -> &'static str {
        match self {
            SortMode::Priority => "priority",
            SortMode::Project => "project",
            SortMode::Recency => "recency",
            SortMode::Natural => "natural",
        }
    }

    /// Parse from storage string.
    fn from_str(s: &str) -> Self {
        match s.trim().to_lowercase().as_str() {
            "project" => SortMode::Project,
            "recency" => SortMode::Recency,
            "natural" => SortMode::Natural,
            _ => SortMode::Priority, // Default fallback
        }
    }

    /// Load sort mode from StateStore.
    pub fn load() -> Self {
        StateStore::new()
            .ok()
            .and_then(|store| store.load_settings().ok())
            .map(|s| Self::from_str(&s.sort_mode))
            .unwrap_or_default()
    }

    /// Save sort mode to StateStore.
    pub fn save(&self) {
        if let Ok(store) = StateStore::new()
            && let Ok(mut settings) = store.load_settings()
        {
            settings.sort_mode = self.as_str().to_string();
            let _ = store.save_settings(&settings);
        }
    }
}

/// Available sort modes for the worktree list
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum WorktreeSortMode {
    /// Git worktree list order
    #[default]
    Natural,
    /// Sort by creation time (newest first)
    Age,
}

impl WorktreeSortMode {
    pub fn next(self) -> Self {
        match self {
            WorktreeSortMode::Natural => WorktreeSortMode::Age,
            WorktreeSortMode::Age => WorktreeSortMode::Natural,
        }
    }

    pub fn label(&self) -> &'static str {
        match self {
            WorktreeSortMode::Natural => "natural",
            WorktreeSortMode::Age => "age",
        }
    }

    fn as_str(&self) -> &'static str {
        self.label()
    }

    fn from_str(s: &str) -> Self {
        match s.trim().to_lowercase().as_str() {
            "age" => WorktreeSortMode::Age,
            _ => WorktreeSortMode::Natural,
        }
    }

    pub fn load() -> Self {
        StateStore::new()
            .ok()
            .and_then(|store| store.load_settings().ok())
            .and_then(|s| s.worktree_sort_mode)
            .map(|s| Self::from_str(&s))
            .unwrap_or_default()
    }

    pub fn save(&self) {
        if let Ok(store) = StateStore::new()
            && let Ok(mut settings) = store.load_settings()
        {
            settings.worktree_sort_mode = Some(self.as_str().to_string());
            let _ = store.save_settings(&settings);
        }
    }
}