jj-ryu 0.0.1-alpha.8

Stacked PRs for Jujutsu with GitHub/GitLab support
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

//! Shared CLI progress callback with styled output and spinners

use crate::cli::style::{Stream, Stylize, check, cross, hyperlink_url};
use anstream::{eprintln, print, println};
use async_trait::async_trait;
use jj_ryu::error::Error;
use jj_ryu::submit::{Phase, ProgressCallback, PushStatus};
use jj_ryu::types::PullRequest;
use std::io::Write;

/// CLI progress callback that prints to stdout with styled output
///
/// Two modes:
/// - verbose (submit): shows all phases, detailed messages
/// - compact (sync): inline status updates, indented for nested output
pub struct CliProgress {
    /// Verbose mode shows all phases and detailed output
    pub verbose: bool,
}

impl CliProgress {
    /// Create verbose progress (for submit command)
    pub const fn verbose() -> Self {
        Self { verbose: true }
    }

    /// Create compact progress (for sync command)
    pub const fn compact() -> Self {
        Self { verbose: false }
    }
}

#[async_trait]
impl ProgressCallback for CliProgress {
    async fn on_phase(&self, phase: Phase) {
        if self.verbose {
            println!("{}...", phase.to_string().emphasis());
        } else {
            match phase {
                Phase::Executing | Phase::AddingComments => {
                    println!("  {}...", phase.to_string().muted());
                }
                _ => {}
            }
        }
    }

    async fn on_bookmark_push(&self, bookmark: &str, status: PushStatus) {
        if self.verbose {
            match &status {
                PushStatus::Started => {
                    println!("  Pushing {}...", bookmark.accent());
                }
                PushStatus::Success => {
                    println!("  {} Pushed {}", check(), bookmark.emphasis());
                }
                PushStatus::AlreadySynced => {
                    println!(
                        "  {} {} {}",
                        "-".muted(),
                        bookmark.accent(),
                        status.to_string().muted()
                    );
                }
                PushStatus::Failed(_) => {
                    eprintln!(
                        "  {} Failed to push {}: {}",
                        cross(),
                        bookmark.accent().for_stderr(),
                        status.to_string().error()
                    );
                }
            }
        } else {
            match &status {
                PushStatus::Started => {
                    print!("    Pushing {}... ", bookmark.accent());
                    let _ = std::io::stdout().flush();
                }
                PushStatus::Success => {
                    println!("{}", "done".success());
                }
                _ => {
                    // Use warn style but on stdout for inline status
                    println!("{}", status.to_string().warn().for_stdout());
                }
            }
        }
    }

    async fn on_pr_created(&self, bookmark: &str, pr: &PullRequest) {
        let pr_num = format!("#{}", pr.number);
        if self.verbose {
            println!(
                "  {} Created PR {} for {}",
                check(),
                pr_num.accent(),
                bookmark.emphasis()
            );
            println!("    {}", hyperlink_url(Stream::Stdout, &pr.html_url));
        } else {
            println!(
                "    Created PR {} for {} ({})",
                pr_num.accent(),
                bookmark.accent(),
                hyperlink_url(Stream::Stdout, &pr.html_url)
            );
        }
    }

    async fn on_pr_updated(&self, bookmark: &str, pr: &PullRequest) {
        let pr_num = format!("#{}", pr.number);
        if self.verbose {
            println!(
                "  {} Updated PR {} for {}",
                check(),
                pr_num.accent(),
                bookmark.emphasis()
            );
        } else {
            println!(
                "    Updated PR {} for {}",
                pr_num.accent(),
                bookmark.accent()
            );
        }
    }

    async fn on_error(&self, err: &Error) {
        if self.verbose {
            eprintln!("{}: {}", "error".error(), err);
        } else {
            eprintln!("    {}: {}", "error".error(), err);
        }
    }

    async fn on_message(&self, message: &str) {
        if self.verbose {
            println!("{message}");
        } else {
            println!("  {}", message.muted());
        }
    }
}