repopilot 0.17.0

Local-first CLI for reviewing Git changes, security boundaries, and blast radius before merge.
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

//! Tests for hidden-suggestion summaries and applying a visibility profile to a
//! whole `ScanSummary`. Per-finding `classify_visibility` cases live in `tests`.

use super::*;
use crate::findings::types::{Confidence, FindingCategory, Severity};
use crate::scan::types::{ScanArtifacts, ScanMetadata, ScanMetrics};

fn finding(rule_id: &str, category: FindingCategory, severity: Severity) -> Finding {
    Finding {
        rule_id: rule_id.to_string(),
        category,
        severity,
        confidence: Confidence::High,
        ..Default::default()
    }
}

#[test]
fn hidden_suggestion_summary_groups_by_intent_rule_and_reason() {
    let findings = vec![
        finding(
            "architecture.large-file",
            FindingCategory::Architecture,
            Severity::High,
        ),
        finding(
            "architecture.large-file",
            FindingCategory::Architecture,
            Severity::High,
        ),
        finding(
            "testing.source-without-test",
            FindingCategory::Testing,
            Severity::Low,
        ),
    ];

    let summaries = build_hidden_suggestion_summaries(&findings);

    assert_eq!(summaries.len(), 2);
    assert_eq!(summaries[0].rule_id, "architecture.large-file");
    assert_eq!(summaries[0].intent, "maintainability");
    assert_eq!(summaries[0].count, 2);
    assert_eq!(summaries[1].rule_id, "testing.source-without-test");
    assert_eq!(summaries[1].intent, "testing-gap");
    assert_eq!(summaries[1].count, 1);
}

#[test]
fn apply_default_profile_recomputes_visible_counts_and_hidden_breakdown() {
    let visible = finding(
        "security.secret-candidate",
        FindingCategory::Security,
        Severity::High,
    );
    let hidden = finding(
        "architecture.large-file",
        FindingCategory::Architecture,
        Severity::High,
    );

    let mut summary = ScanSummary {
        metadata: ScanMetadata {
            ..Default::default()
        },
        metrics: ScanMetrics {
            non_empty_lines: 1_000,
            ..Default::default()
        },
        artifacts: ScanArtifacts {
            hidden_suggestions: Vec::new(),
            findings: vec![visible, hidden],
            ..Default::default()
        },
    };

    apply_visibility_profile(&mut summary, FindingVisibilityProfile::Default);

    assert_eq!(summary.visibility_profile.as_deref(), Some("default"));
    assert_eq!(summary.metrics.raw_findings_count, 2);
    assert_eq!(summary.metrics.visible_findings_count, 1);
    assert_eq!(summary.metrics.hidden_suggestions_count, 1);
    assert_eq!(summary.artifacts.raw_signal_quality.findings_total, 2);
    assert_eq!(summary.artifacts.visible_signal_quality.findings_total, 1);
    assert_eq!(summary.artifacts.signal_quality.findings_total, 1);
    assert_eq!(summary.artifacts.hidden_suggestions.len(), 1);
    assert_eq!(
        summary.artifacts.hidden_suggestions[0].intent,
        "maintainability"
    );
    assert_eq!(
        summary.artifacts.hidden_suggestions[0].rule_id,
        "architecture.large-file"
    );
    assert_eq!(summary.artifacts.findings.len(), 1);
    assert_eq!(
        summary.artifacts.findings[0].rule_id,
        "security.secret-candidate"
    );
}

#[test]
fn strict_profile_keeps_all_findings_and_clears_hidden_breakdown() {
    let mut summary = ScanSummary {
        metadata: ScanMetadata {
            ..Default::default()
        },
        metrics: ScanMetrics {
            non_empty_lines: 1_000,
            ..Default::default()
        },
        artifacts: ScanArtifacts {
            hidden_suggestions: vec![HiddenSuggestionSummary {
                intent: "maintainability".to_string(),
                rule_id: "architecture.large-file".to_string(),
                category: "architecture".to_string(),
                reason: "example".to_string(),
                count: 1,
            }],
            findings: vec![
                finding(
                    "security.secret-candidate",
                    FindingCategory::Security,
                    Severity::High,
                ),
                finding(
                    "architecture.large-file",
                    FindingCategory::Architecture,
                    Severity::High,
                ),
            ],
            ..Default::default()
        },
    };

    apply_visibility_profile(&mut summary, FindingVisibilityProfile::Strict);

    assert_eq!(summary.visibility_profile.as_deref(), Some("strict"));
    assert_eq!(summary.metrics.raw_findings_count, 2);
    assert_eq!(summary.metrics.visible_findings_count, 2);
    assert_eq!(summary.metrics.hidden_suggestions_count, 0);
    assert!(summary.artifacts.hidden_suggestions.is_empty());
    assert_eq!(summary.artifacts.findings.len(), 2);
}