repopilot 0.16.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

use super::summary::{ScanSummaryParts, build_scan_summary};
use super::{full::ProjectAnalysisStage, full::ScanEngine, summary};
use crate::findings::quality::SignalQualitySummary;
use crate::graph::context::{
    ContextGraphCacheInfo, ContextGraphSummary, RepoContextGraph, summarize_context_graph,
    write_repo_context_graph,
};
use crate::scan::cache::config_fingerprint;
use crate::scan::config::ScanConfig;
use crate::scan::types::{ScanDiagnostic, ScanMode, ScanSummary, ScanTimings, cache_diagnostic};
use std::path::Path;
use std::time::Instant;

struct ContextGraphArtifacts {
    summary: ContextGraphSummary,
    cache: Option<ContextGraphCacheInfo>,
}

impl<'a> ScanEngine<'a> {
    pub(super) fn finalize_report(
        &self,
        mut project_stage: ProjectAnalysisStage,
        scan_duration_us: u64,
        timings: ScanTimings,
        diagnostics: Vec<ScanDiagnostic>,
        signal_quality: SignalQualitySummary,
    ) -> ScanSummary {
        let finalization_start = Instant::now();
        let context_graph = prepare_findings_and_context_graph(&mut project_stage);
        let mut diagnostics = diagnostics;
        if crate::graph::was_cycle_detection_depth_exceeded() {
            diagnostics.push(ScanDiagnostic::warning(
                "graph.cycle-depth-exceeded",
                "Cycle detection depth limit (512 hops) was exceeded; some deep transitive cycles may not have been reported.",
            ));
        }
        let context_graph_artifacts = build_context_graph_artifacts(
            &project_stage.facts.root_path,
            self.config,
            &context_graph,
            &project_stage.findings,
            &mut diagnostics,
        );

        let mut summary = build_final_scan_summary(
            project_stage,
            scan_duration_us,
            timings,
            diagnostics,
            signal_quality,
            context_graph_artifacts,
        );

        record_report_finalization_timing(&mut summary, finalization_start);
        summary
    }
}

fn prepare_findings_and_context_graph(
    project_stage: &mut ProjectAnalysisStage,
) -> RepoContextGraph {
    summary::sort_findings(&mut project_stage.findings);

    RepoContextGraph::from_scan_facts(
        &project_stage.facts,
        &project_stage.facts.root_path,
        project_stage.coupling_graph.clone(),
    )
}

fn build_context_graph_artifacts(
    root_path: &Path,
    config: &ScanConfig,
    context_graph: &RepoContextGraph,
    findings: &[crate::findings::types::Finding],
    diagnostics: &mut Vec<ScanDiagnostic>,
) -> ContextGraphArtifacts {
    let graph_summary = summarize_context_graph(context_graph, findings, &[]);
    let fingerprint = config_fingerprint(config);
    let cache = match write_repo_context_graph(root_path, &fingerprint, context_graph) {
        Ok(cache_info) => Some(cache_info),
        Err(error) => {
            diagnostics.push(cache_diagnostic(&error));
            None
        }
    };

    ContextGraphArtifacts {
        summary: graph_summary,
        cache,
    }
}

fn build_final_scan_summary(
    project_stage: ProjectAnalysisStage,
    scan_duration_us: u64,
    timings: ScanTimings,
    diagnostics: Vec<ScanDiagnostic>,
    signal_quality: SignalQualitySummary,
    context_graph_artifacts: ContextGraphArtifacts,
) -> ScanSummary {
    build_scan_summary(
        project_stage.facts,
        project_stage.findings,
        ScanSummaryParts {
            mode: ScanMode::Full,
            base_ref: None,
            changed_files_count: 0,
            repo_level_rules_included: true,
            coupling_graph: Some(project_stage.coupling_graph),
            scan_duration_us,
            scan_timings: Some(timings),
            cache_telemetry: None,
            diagnostics,
            signal_quality,
            context_graph_summary: Some(context_graph_artifacts.summary),
            context_graph_cache: context_graph_artifacts.cache,
        },
    )
}

fn record_report_finalization_timing(summary: &mut ScanSummary, finalization_start: Instant) {
    if let Some(timings) = &mut summary.scan_timings {
        timings.report_finalization_us = finalization_start.elapsed().as_micros() as u64;
    }
}