weavatrix-scan 0.4.6

Deterministic, safe repository scanner for code intelligence
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

use crate::report::{CompactScanReport, FileVersion, ScanReport};
use crate::watch::WatchPlan;
use std::path::{Path, PathBuf};

/// Current on-disk format understood by [`ScanCache`].
pub const SCAN_CACHE_FORMAT_VERSION: u32 = 2;

/// Compact reusable evidence for one content-hashed file.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ScanCacheEntry {
    pub relative: String,
    pub bytes: u64,
    pub content_hash: String,
    #[cfg_attr(feature = "serde", serde(default))]
    pub content_fingerprint: String,
    pub version: FileVersion,
    pub binary_checked: bool,
}

/// Versioned local cache for incremental scans.
///
/// Unlike [`ScanReport`], this contains no absolute per-file paths, skipped
/// entries, warnings, ignore diagnostics, or manifest metadata.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ScanCache {
    pub format_version: u32,
    #[cfg_attr(feature = "serde", serde(with = "crate::path_serde"))]
    pub root: PathBuf,
    pub entries: Vec<ScanCacheEntry>,
}

impl ScanCache {
    /// Builds a compact cache from reusable SHA-256 evidence.
    #[must_use]
    pub fn from_report(report: &ScanReport) -> Self {
        let entries = report
            .files
            .iter()
            .filter_map(|file| {
                let content_hash = file
                    .content_hash
                    .as_ref()
                    .filter(|hash| hash.starts_with("sha256:"))?
                    .clone();
                Some(ScanCacheEntry {
                    relative: file.relative.clone(),
                    bytes: file.bytes,
                    content_hash,
                    content_fingerprint: file.content_fingerprint.clone()?,
                    version: file.version,
                    binary_checked: file.binary_checked,
                })
            })
            .collect();
        Self {
            format_version: SCAN_CACHE_FORMAT_VERSION,
            root: report.root.clone(),
            entries,
        }
    }

    /// Returns whether this cache can be considered for `root`.
    #[must_use]
    pub fn is_compatible(&self, root: &Path) -> bool {
        self.format_version == SCAN_CACHE_FORMAT_VERSION && self.root == root
    }

    /// Removes reusable entries for the supplied normalized relative paths.
    ///
    /// Returns the number of entries removed.
    pub fn invalidate<'a, I>(&mut self, relative_paths: I) -> usize
    where
        I: IntoIterator<Item = &'a str>,
    {
        let paths = relative_paths
            .into_iter()
            .collect::<std::collections::HashSet<_>>();
        let before = self.entries.len();
        self.entries
            .retain(|entry| !paths.contains(entry.relative.as_str()));
        before - self.entries.len()
    }

    /// Applies a watcher plan, clearing everything when selection may change.
    ///
    /// Returns the number of entries removed.
    pub fn apply_watch_plan(&mut self, plan: &WatchPlan) -> usize {
        if plan.full_rescan {
            let removed = self.entries.len();
            self.entries.clear();
            return removed;
        }
        self.invalidate(plan.invalidated())
    }
}

impl ScanReport {
    /// Extracts the compact, versioned evidence needed for a later scan.
    #[must_use]
    pub fn to_cache(&self) -> ScanCache {
        ScanCache::from_report(self)
    }
}

impl CompactScanReport {
    /// Extracts reusable SHA-256 evidence without materializing absolute paths.
    #[must_use]
    pub fn to_cache(&self) -> ScanCache {
        let entries = self
            .files
            .iter()
            .filter_map(|file| {
                let content = file.content.as_deref()?;
                let content_hash = content
                    .content_hash
                    .as_deref()
                    .filter(|hash| hash.starts_with("sha256:"))?
                    .to_owned();
                Some(ScanCacheEntry {
                    relative: file.relative.to_string(),
                    bytes: file.bytes,
                    content_hash,
                    content_fingerprint: content.content_fingerprint.as_deref()?.to_owned(),
                    version: content.version,
                    binary_checked: content.binary_checked,
                })
            })
            .collect();
        ScanCache {
            format_version: SCAN_CACHE_FORMAT_VERSION,
            root: self.root.clone(),
            entries,
        }
    }
}