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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Remote repository commands.
//!
//! Handles remote operations including pruning, URL management, and fetching.

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

/// Remote prune (remove stale tracking branches)
pub struct RemotePruneCommand {
    pub remote: String,
}

impl Command for RemotePruneCommand {
    #[instrument(skip(self, git, state), fields(remote = %self.remote))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        let remote = if self.remote.is_empty() { "origin" } else { self.remote.as_str() };
        new_state = reducer(new_state, Action::SetOpStatus(Some(format!("remote prune {}…", remote))));
        match git.remote_prune(&state.repo_path, remote) {
            Ok(output) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("remote prune {} ok", remote)));
                if !output.trim().is_empty() {
                    new_state = reducer(new_state, Action::AppendOpLog(output));
                }
                new_state = reducer(new_state, Action::SetFeedback(Some(format!("Pruned stale tracking on {}", remote))));
                new_state = reducer(new_state, Action::SetRefreshing(true));
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("remote prune error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("remote prune error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}

/// Show remote URL
pub struct ShowRemoteUrlCommand {
    pub remote: String,
}

impl Command for ShowRemoteUrlCommand {
    #[instrument(skip(self, git, state), fields(remote = %self.remote))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        new_state = reducer(new_state, Action::SetOpStatus(Some(format!("remote url {}…", self.remote))));
        match git.remote_url(&state.repo_path, &self.remote) {
            Ok(url) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("{} url: {}", self.remote, url)));
                new_state = reducer(new_state, Action::SetFeedback(Some(format!("{} url: {}", self.remote, url))));
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("remote url error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("remote url error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}

/// Set remote URL to SSH form if needed
pub struct SetRemoteSshCommand {
    pub remote: String,
}

impl Command for SetRemoteSshCommand {
    #[instrument(skip(self, git, state), fields(remote = %self.remote))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        let remote = self.remote.as_str();
        new_state = reducer(new_state, Action::SetOpStatus(Some(format!("ensure ssh remote {}…", remote))));
        match git.remote_url(&state.repo_path, remote) {
            Ok(url) => {
                if url.starts_with("git@") || url.starts_with("ssh://") {
                    new_state = reducer(new_state, Action::AppendOpLog(format!("{} already SSH: {}", remote, url)));
                    new_state = reducer(new_state, Action::SetFeedback(Some(format!("{} already SSH", remote))));
                } else if let Some(ssh_url) = to_ssh_url(&url) {
                    match git.set_remote_url(&state.repo_path, remote, &ssh_url) {
                        Ok(_) => {
                            new_state = reducer(new_state, Action::AppendOpLog(format!("{} -> {}", url, ssh_url)));
                            new_state = reducer(new_state, Action::SetFeedback(Some(format!("Set {} to SSH", remote))));
                        }
                        Err(e) => {
                            new_state = reducer(new_state, Action::AppendOpLog(format!("set-url error: {e}")));
                            new_state = reducer(new_state, Action::SetStatusError(Some(format!("set-url error: {e}"))));
                        }
                    }
                } else {
                    new_state = reducer(new_state, Action::AppendOpLog(format!("cannot convert to ssh: {}", url)));
                    new_state = reducer(new_state, Action::SetStatusError(Some("cannot convert remote to ssh".into())));
                }
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("remote url error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("remote url error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}

/// Auto-fetch from remote
pub struct AutoFetchCommand {
    pub remote: String,
}

impl Command for AutoFetchCommand {
    #[instrument(skip(self, git, state), fields(remote = %self.remote))]
    fn execute(
        &self,
        git: &GitService,
        state: &AppState,
    ) -> Result<CommandResult, CommandError> {
        let mut new_state = state.clone();
        let remote = if self.remote.is_empty() { "origin" } else { self.remote.as_str() };
        new_state = reducer(new_state, Action::SetOpStatus(Some(format!("fetching {}…", remote))));
        match git.fetch_dry_run(&state.repo_path, remote) {
            Ok(output) => {
                if !output.trim().is_empty() {
                    for line in output.lines() {
                        new_state = reducer(new_state, Action::AppendOpLog(line.to_string()));
                    }
                } else {
                    new_state = reducer(new_state, Action::AppendOpLog(format!("fetch {}: up to date", remote)));
                }
                new_state = reducer(new_state, Action::SetRefreshing(true));
            }
            Err(e) => {
                new_state = reducer(new_state, Action::AppendOpLog(format!("fetch error: {e}")));
                new_state = reducer(new_state, Action::SetStatusError(Some(format!("fetch error: {e}"))));
            }
        }
        new_state = reducer(new_state, Action::SetOpStatus(None));
        Ok(CommandResult::StateUpdate(new_state))
    }
}