eazygit 0.5.1

A fast TUI for Git with staging, conflicts, rebase, and palette-first UX
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

use crate::commands::{Command, CommandResult, CommandError};
use crate::app::{AppState, Action, reducer};
use crate::services::GitService;
use tracing::instrument;

/// Apply a stash (without dropping)
pub struct ApplyStashCommand {
    pub name: String,
}

impl Command for ApplyStashCommand {
    #[instrument(skip(self, git, state), fields(name = %self.name))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        new_state = reducer(new_state, Action::SetOpStatus(Some("applying stash…".into())));
        match git.stash_apply(&state.repo_path, &self.name, false) {
            Ok(_) => {
                new_state = reducer(new_state, Action::SetFeedback(Some(format!("Applied stash {}", self.name))));
                new_state = reducer(new_state, Action::SetRefreshing(true));
                new_state = reducer(new_state, Action::AppendOpLog(format!("applied stash {}", self.name)));
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("stash apply error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("stash apply error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}

/// Pop a stash (apply and drop)
pub struct PopStashCommand {
    pub name: String,
}

impl Command for PopStashCommand {
    #[instrument(skip(self, git, state), fields(name = %self.name))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        new_state = reducer(new_state, Action::SetOpStatus(Some("popping stash…".into())));
        match git.stash_apply(&state.repo_path, &self.name, true) {
            Ok(_) => {
                new_state = reducer(new_state, Action::SetFeedback(Some(format!("Popped stash {}", self.name))));
                new_state = reducer(new_state, Action::SetRefreshing(true));
                new_state = reducer(new_state, Action::AppendOpLog(format!("popped stash {}", self.name)));
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("stash pop error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("stash pop error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}

/// Create a new stash
pub struct CreateStashCommand {
    pub message: String,
}

impl Command for CreateStashCommand {
    #[instrument(skip(self, git, state), fields(message = %self.message))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        new_state = reducer(new_state, Action::SetOpStatus(Some("creating stash…".into())));
        match git.stash_push(&state.repo_path, &self.message) {
            Ok(_) => {
                new_state = reducer(new_state, Action::SetFeedback(Some(format!("Created stash: {}", if self.message.is_empty() { "untitled" } else { &self.message }))));
                new_state.stash_create_mode = false;
                new_state.stash_message_input.clear();
                new_state = reducer(new_state, Action::AppendOpLog(format!("created stash: {}", if self.message.is_empty() { "untitled" } else { &self.message })));
                // Explicitly refresh stashes list after creation
                new_state = reducer(new_state, Action::RefreshStashes);
            }
            Err(e) => {
                // On error, keep stash_create_mode open so user can try again or cancel
                new_state = reducer(new_state, Action::AppendOpLog(format!("stash create error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("stash create error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}

/// Delete a stash
/// 
/// Deletes the specified stash. On success, refreshes the stashes list to reflect the deletion.
/// The stash_selected index is automatically adjusted by the reducer if it becomes out of bounds.
pub struct DeleteStashCommand {
    pub name: String,
}

impl Command for DeleteStashCommand {
    #[instrument(skip(self, git, state), fields(name = %self.name))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        new_state = reducer(new_state, Action::SetOpStatus(Some("deleting stash…".into())));
        match git.stash_drop(&state.repo_path, &self.name) {
            Ok(_) => {
                new_state = reducer(new_state, Action::SetFeedback(Some(format!("Deleted stash {}", self.name))));
                new_state = reducer(new_state, Action::AppendOpLog(format!("deleted stash {}", self.name)));
                // Explicitly refresh stashes list after deletion to update the UI
                // The reducer will automatically adjust stash_selected if it's out of bounds
                new_state = reducer(new_state, Action::RefreshStashes);
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("stash drop error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("stash drop error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}