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

use super::*;

impl<'a> ChangedScanEngine<'a> {
    pub(super) fn finalize_report(
        &self,
        scan_start: Instant,
        discovery: ChangedDiscoveryStage,
        mut file_stage: ChangedFileAnalysisStage,
        repo_stage: ChangedRepoContextStage,
        finding_pipeline: ChangedFindingPipelineStage,
    ) -> io::Result<ScanSummary> {
        let finalization_start = Instant::now();

        super::summary::sort_findings(&mut file_stage.findings);
        let context_graph_summary = summarize_context_graph(
            &repo_stage.context_graph,
            &file_stage.findings,
            &discovery.changed_files,
        );
        let mut diagnostics = repo_stage.diagnostics;
        diagnostics.extend(finding_pipeline.diagnostics);

        let cache_write_start = Instant::now();
        file_stage.cache.write(&discovery.repo_root)?;
        file_stage.cache_telemetry.timings.write_us =
            cache_write_start.elapsed().as_micros() as u64;
        finalize_cache_telemetry(
            &mut file_stage.cache_telemetry,
            file_stage.changed_file_reasons,
        );

        file_stage.facts.root_path = self.path.to_path_buf();

        let scan_duration_us = scan_start.elapsed().as_micros() as u64;
        let file_scan_us = discovery.elapsed_us.saturating_add(file_stage.elapsed_us);

        let mut summary = build_scan_summary(
            file_stage.facts,
            file_stage.findings,
            ScanSummaryParts {
                mode: ScanMode::Changed,
                base_ref: self.base_ref.map(str::to_string),
                changed_files_count: discovery.changed_files.len(),
                repo_level_rules_included: false,
                coupling_graph: None,
                scan_duration_us,
                scan_timings: Some(ScanTimings {
                    discovery_us: discovery.elapsed_us,
                    file_analysis_us: file_stage.elapsed_us,
                    parse_us: file_stage.parse_us,
                    file_scan_us,
                    framework_detection_us: repo_stage.elapsed_us,
                    post_scan_audits_us: 0,
                    enrichment_us: finding_pipeline.enrichment_us,
                    risk_scoring_us: finding_pipeline.risk_scoring_us,
                    contract_validation_us: finding_pipeline.contract_validation_us,
                    report_finalization_us: 0,
                }),
                cache_telemetry: Some(file_stage.cache_telemetry),
                context_graph_summary: Some(context_graph_summary),
                context_graph_cache: Some(repo_stage.cache_info),
                diagnostics,
                signal_quality: finding_pipeline.signal_quality,
            },
        );

        if let Some(timings) = &mut summary.scan_timings {
            timings.report_finalization_us = finalization_start.elapsed().as_micros() as u64;
        }

        Ok(summary)
    }

    pub(super) fn finalize_empty_changed(
        &self,
        scan_start: Instant,
        discovery: ChangedDiscoveryStage,
    ) -> io::Result<ScanSummary> {
        let finalization_start = Instant::now();
        let scan_duration_us = scan_start.elapsed().as_micros() as u64;
        let mut summary = build_scan_summary(
            ScanFacts {
                root_path: self.path.to_path_buf(),
                ..ScanFacts::default()
            },
            Vec::new(),
            ScanSummaryParts {
                mode: ScanMode::Changed,
                base_ref: self.base_ref.map(str::to_string),
                changed_files_count: 0,
                repo_level_rules_included: false,
                coupling_graph: None,
                scan_duration_us,
                scan_timings: Some(ScanTimings {
                    discovery_us: discovery.elapsed_us,
                    file_analysis_us: 0,
                    parse_us: 0,
                    file_scan_us: discovery.elapsed_us,
                    framework_detection_us: 0,
                    post_scan_audits_us: 0,
                    enrichment_us: 0,
                    risk_scoring_us: 0,
                    contract_validation_us: 0,
                    report_finalization_us: 0,
                }),
                cache_telemetry: None,
                context_graph_summary: None,
                context_graph_cache: None,
                diagnostics: Vec::new(),
                signal_quality: SignalQualitySummary::default(),
            },
        );
        if let Some(timings) = &mut summary.scan_timings {
            timings.report_finalization_us = finalization_start.elapsed().as_micros() as u64;
        }
        Ok(summary)
    }
}