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

//! Go import resolution, using the `go.mod` module path (cached per repo root)
//! with a fallback to the repository directory name.

use super::{normalize_path, probe};
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::{OnceLock, RwLock};

static GO_MODULE_CACHE: OnceLock<RwLock<HashMap<PathBuf, Option<String>>>> = OnceLock::new();

fn get_go_module_cache() -> &'static RwLock<HashMap<PathBuf, Option<String>>> {
    GO_MODULE_CACHE.get_or_init(|| RwLock::new(HashMap::new()))
}

pub(super) fn resolve_go(
    raw: &str,
    root: &Path,
    known_files: &HashSet<PathBuf>,
) -> Option<PathBuf> {
    if !raw.contains('/') {
        return None;
    }

    if let Some(module_name) = read_go_module_name(root)
        && let Some(rest) = strip_go_module_prefix(raw, &module_name)
    {
        let rel = rest.trim_start_matches('/');
        let base = if rel.is_empty() {
            root.to_path_buf()
        } else {
            root.join(rel)
        };
        if let Some(path) = probe_go_package(&normalize_path(&base), known_files) {
            return Some(path);
        }
    }

    let root_name = root
        .file_name()
        .and_then(|name| name.to_str())
        .unwrap_or("");
    if !root_name.is_empty()
        && let Some(rest) = strip_go_module_prefix(raw, root_name)
    {
        let rel = rest.trim_start_matches('/');
        let base = normalize_path(&root.join(rel));
        return probe_go_package(&base, known_files);
    }

    None
}

fn strip_go_module_prefix<'a>(raw: &'a str, module_name: &str) -> Option<&'a str> {
    raw.strip_prefix(module_name)
        .filter(|rest| rest.is_empty() || rest.starts_with('/'))
}

fn probe_go_package(base: &Path, known_files: &HashSet<PathBuf>) -> Option<PathBuf> {
    if let Some(path) = probe(&[base.with_extension("go")], known_files) {
        return Some(path);
    }

    let package_dir = normalize_path(base);
    known_files
        .iter()
        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("go"))
        .filter(|path| {
            path.file_name()
                .and_then(|name| name.to_str())
                .is_none_or(|name| !name.ends_with("_test.go"))
        })
        .filter(|path| path.parent() == Some(package_dir.as_path()))
        .min()
        .cloned()
}

fn read_go_module_name(root: &Path) -> Option<String> {
    let cache = get_go_module_cache();
    if let Some(cached) = cache.read().unwrap().get(root) {
        return cached.clone();
    }

    let module = std::fs::read_to_string(root.join("go.mod"))
        .ok()
        .and_then(|content| {
            content.lines().find_map(|line| {
                line.trim()
                    .strip_prefix("module ")
                    .map(|module| module.trim().to_string())
            })
        });
    cache
        .write()
        .unwrap()
        .insert(root.to_path_buf(), module.clone());
    module
}