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

mod algorithms;
mod builder;
mod capabilities;
mod coupling_snapshot;
mod diagnostic;
mod edge;
mod node;
mod snapshot;

pub use algorithms::{
    DirectoryDependency, GraphBlastRadius, GraphCycle, GraphDegreeSummary,
    GraphDirectoryDependencies, GraphNeighborhood, GraphV2Summary, NodeDegree, blast_radius,
    compute_degrees, direct_dependents, directory_dependencies, find_cycles, neighborhood,
    shortest_cycle, summarize_graph, top_fan_in, top_fan_out,
};
pub use builder::graph_snapshot_from_scan;
pub use capabilities::{GraphCapabilities, graph_capabilities};
pub use coupling_snapshot::build_coupling_graph_snapshot;
pub use diagnostic::GraphDiagnostic;
pub use edge::{GraphEdge, GraphEdgeConfidence, GraphEdgeKind, GraphEdgeProvenance};
pub use node::{GraphNode, GraphNodeId, GraphNodeKind};
pub use snapshot::GraphSnapshot;

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn node_id_stores_value_and_sorts_deterministically() {
        let first = GraphNodeId::new("file:src/a.rs");
        let second = GraphNodeId::new("file:src/b.rs");
        let mut ids = [second, first.clone()];

        ids.sort();

        assert_eq!(first.as_str(), "file:src/a.rs");
        assert_eq!(ids[0], first);
    }

    #[test]
    fn new_snapshot_is_empty() {
        let snapshot = GraphSnapshot::new();

        assert_eq!(snapshot.node_count(), 0);
        assert_eq!(snapshot.edge_count(), 0);
        assert_eq!(snapshot.diagnostic_count(), 0);
    }

    #[test]
    fn snapshot_adds_nodes_edges_and_diagnostics() {
        let source_id = GraphNodeId::new("file:src/lib.rs");
        let target_id = GraphNodeId::new("external:serde");
        let mut snapshot = GraphSnapshot::new();

        snapshot.add_node(GraphNode {
            id: source_id.clone(),
            kind: GraphNodeKind::File,
            label: "src/lib.rs".to_string(),
            path: Some(PathBuf::from("src/lib.rs")),
        });
        snapshot.add_node(GraphNode {
            id: target_id.clone(),
            kind: GraphNodeKind::ExternalDependency,
            label: "serde".to_string(),
            path: None,
        });
        snapshot.add_edge(GraphEdge {
            from: source_id.clone(),
            to: target_id.clone(),
            kind: GraphEdgeKind::DependsOn,
            provenance: GraphEdgeProvenance::Import,
            confidence: GraphEdgeConfidence::High,
        });
        snapshot.add_diagnostic(GraphDiagnostic {
            code: "graph.unresolved-import".to_string(),
            message: "could not resolve one import".to_string(),
            path: Some(PathBuf::from("src/lib.rs")),
        });

        assert_eq!(snapshot.node_count(), 2);
        assert_eq!(snapshot.edge_count(), 1);
        assert_eq!(snapshot.diagnostic_count(), 1);
        assert_eq!(
            snapshot.nodes[0].path.as_deref(),
            Some(std::path::Path::new("src/lib.rs"))
        );
        assert!(snapshot.nodes[1].path.is_none());
        assert_eq!(snapshot.edges[0].from, source_id);
        assert_eq!(snapshot.edges[0].to, target_id);
        assert_eq!(snapshot.edges[0].kind, GraphEdgeKind::DependsOn);
    }
}