aptu-cli 0.3.1

CLI for Aptu - Gamified OSS issue triage with AI assistance
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

// SPDX-License-Identifier: Apache-2.0

use anyhow::{Context, Result};
use console::style;
use std::io::{self, Write};

use crate::cli::{OutputContext, OutputFormat};
use crate::commands::types::{DiscoverResult, ReposResult};

use super::Renderable;

impl Renderable for ReposResult {
    fn render_text(&self, w: &mut dyn Write, _ctx: &OutputContext) -> io::Result<()> {
        writeln!(w)?;
        writeln!(w, "{}", style("Available repositories:").bold())?;
        writeln!(w)?;

        for (i, repo) in self.repos.iter().enumerate() {
            let num = format!("{:>3}.", i + 1);
            let name = format!("{:<25}", repo.full_name());
            let lang = format!("{:<10}", repo.language);

            writeln!(
                w,
                "  {} {} {} {}",
                style(num).dim(),
                style(name).cyan(),
                style(lang).yellow(),
                style(&repo.description).dim()
            )?;
        }

        writeln!(w)?;
        Ok(())
    }

    fn render_markdown(&self, w: &mut dyn Write, _ctx: &OutputContext) -> io::Result<()> {
        writeln!(w, "## Available Repositories\n")?;
        for repo in &self.repos {
            writeln!(
                w,
                "- **{}** ({}) - {}",
                repo.full_name(),
                repo.language,
                &repo.description
            )?;
        }
        Ok(())
    }
}

impl Renderable for DiscoverResult {
    fn render_text(&self, w: &mut dyn Write, _ctx: &OutputContext) -> io::Result<()> {
        writeln!(w)?;
        writeln!(w, "{}", style("Discovered repositories:").bold())?;
        writeln!(w)?;

        for (i, repo) in self.repos.iter().enumerate() {
            let num = format!("{:>3}.", i + 1);
            let name = format!("{:<25}", repo.full_name());
            let stars = format!("{:>5} stars", repo.stars);
            let score = format!("score: {}", repo.score);

            writeln!(
                w,
                "  {} {} {} {}",
                style(num).dim(),
                style(name).cyan(),
                style(stars).yellow(),
                style(score).green()
            )?;

            if let Some(lang) = &repo.language {
                writeln!(w, "     Language: {}", style(lang).dim())?;
            }

            if let Some(desc) = &repo.description {
                writeln!(w, "     {}", style(desc).dim())?;
            }

            writeln!(w, "     {}", style(&repo.url).blue())?;
        }

        writeln!(w)?;
        Ok(())
    }

    fn render_markdown(&self, w: &mut dyn Write, _ctx: &OutputContext) -> io::Result<()> {
        writeln!(w, "## Discovered Repositories\n")?;
        for repo in &self.repos {
            writeln!(
                w,
                "- **{}** ({} stars, score: {}) - [{}]({})",
                repo.full_name(),
                repo.stars,
                repo.score,
                repo.language.as_deref().unwrap_or("Unknown"),
                repo.url
            )?;
            if let Some(desc) = &repo.description {
                writeln!(w, "  - {desc}")?;
            }
        }
        Ok(())
    }
}

// Special handling for ReposResult to maintain backward compatibility with JSON output
impl ReposResult {
    pub fn render_with_context(&self, ctx: &OutputContext) -> Result<()> {
        match ctx.format {
            OutputFormat::Json => {
                // Output just the repos array for backward compatibility
                let json = serde_json::to_string_pretty(&self.repos)
                    .context("Failed to serialize repos to JSON")?;
                println!("{json}");
            }
            OutputFormat::Yaml => {
                // Output just the repos array for backward compatibility
                let yaml = serde_saphyr::to_string(&self.repos)
                    .context("Failed to serialize repos to YAML")?;
                println!("{yaml}");
            }
            _ => {
                // Use the trait implementation for text/markdown
                super::render(self, ctx)?;
            }
        }
        Ok(())
    }
}

// Special handling for DiscoverResult to maintain backward compatibility with JSON output
impl DiscoverResult {
    pub fn render_with_context(&self, ctx: &OutputContext) -> Result<()> {
        match ctx.format {
            OutputFormat::Json => {
                // Output just the repos array for backward compatibility
                let json = serde_json::to_string_pretty(&self.repos)
                    .context("Failed to serialize repos to JSON")?;
                println!("{json}");
            }
            OutputFormat::Yaml => {
                // Output just the repos array for backward compatibility
                let yaml = serde_saphyr::to_string(&self.repos)
                    .context("Failed to serialize repos to YAML")?;
                println!("{yaml}");
            }
            _ => {
                // Use the trait implementation for text/markdown
                super::render(self, ctx)?;
            }
        }
        Ok(())
    }
}