repopilot 0.14.0

Local-first CLI for repository audit, architecture risk detection, baseline tracking, and CI-friendly code review.
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

pub mod ai_context;
pub mod ai_plan;
pub mod color;
pub mod console;
pub(crate) mod finding_helpers;
pub mod html;
pub mod json;
pub mod markdown;
pub mod prompt;
pub(crate) mod render_helpers;
pub(crate) mod report_stats;
pub(crate) mod report_text;
pub mod rules;
pub mod sarif;

use crate::baseline::diff::BaselineScanReport;
use crate::baseline::gate::CiGateResult;
use crate::scan::types::ScanSummary;
use serde::Deserialize;

pub use color::{ColorChoice, ColorDestination};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum OutputFormat {
    Console,
    Html,
    Json,
    Markdown,
    Sarif,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ConsoleOutputStyle {
    Compact,
    Full,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FindingRenderLimit {
    Default,
    Limit(usize),
    Unlimited,
}

impl FindingRenderLimit {
    pub fn compact_limit(self, total: usize) -> usize {
        match self {
            Self::Default => total.min(5),
            Self::Limit(limit) => total.min(limit),
            Self::Unlimited => total,
        }
    }

    pub fn detailed_limit(self, total: usize) -> usize {
        match self {
            Self::Default | Self::Unlimited => total,
            Self::Limit(limit) => total.min(limit),
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct RenderOptions {
    pub console_output_style: ConsoleOutputStyle,
    pub color_choice: ColorChoice,
    pub color_destination: ColorDestination,
    pub quiet: bool,
    pub findings_limit: FindingRenderLimit,
}

impl Default for RenderOptions {
    fn default() -> Self {
        Self {
            console_output_style: ConsoleOutputStyle::Full,
            color_choice: ColorChoice::Auto,
            color_destination: ColorDestination::Stdout,
            quiet: false,
            findings_limit: FindingRenderLimit::Default,
        }
    }
}

impl RenderOptions {
    fn color_enabled(self) -> bool {
        color::resolve_color_enabled(self.color_choice, self.color_destination)
    }
}

pub fn render_scan_summary(
    summary: &ScanSummary,
    format: OutputFormat,
) -> Result<String, serde_json::Error> {
    render_scan_summary_with_options(summary, format, RenderOptions::default())
}

pub fn render_scan_summary_with_options(
    summary: &ScanSummary,
    format: OutputFormat,
    options: RenderOptions,
) -> Result<String, serde_json::Error> {
    match format {
        OutputFormat::Console => Ok(color::with_color_enabled(options.color_enabled(), || {
            console::render_with_options(summary, options)
        })),
        OutputFormat::Html => Ok(html::render(summary)),
        OutputFormat::Json => json::render(summary),
        OutputFormat::Markdown => Ok(markdown::render_with_options(summary, options)),
        OutputFormat::Sarif => sarif::render(summary),
    }
}

pub fn render_baseline_scan_report(
    report: &BaselineScanReport,
    format: OutputFormat,
    ci_gate: Option<&CiGateResult>,
) -> Result<String, serde_json::Error> {
    render_baseline_scan_report_with_options(report, format, ci_gate, RenderOptions::default())
}

pub fn render_baseline_scan_report_with_options(
    report: &BaselineScanReport,
    format: OutputFormat,
    ci_gate: Option<&CiGateResult>,
    options: RenderOptions,
) -> Result<String, serde_json::Error> {
    match format {
        OutputFormat::Console => Ok(color::with_color_enabled(options.color_enabled(), || {
            console::render_baseline_with_options(report, ci_gate, options)
        })),
        OutputFormat::Html => Ok(html::render_with_baseline(report, ci_gate)),
        OutputFormat::Json => json::render_with_baseline(report, ci_gate),
        OutputFormat::Markdown => Ok(markdown::render_baseline_with_options(
            report, ci_gate, options,
        )),
        OutputFormat::Sarif => sarif::render_with_baseline(report),
    }
}