qex-core 0.0.2

Core library for QEX — semantic code search with BM25, tree-sitter chunking, and optional dense vectors
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::MerkleDAG;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;

/// Represents changes detected between two Merkle DAGs
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FileChanges {
    pub added: Vec<String>,
    pub removed: Vec<String>,
    pub modified: Vec<String>,
    pub unchanged: Vec<String>,
}

impl FileChanges {
    pub fn has_changes(&self) -> bool {
        !self.added.is_empty() || !self.removed.is_empty() || !self.modified.is_empty()
    }

    pub fn total_changed(&self) -> usize {
        self.added.len() + self.removed.len() + self.modified.len()
    }
}

/// Detects changes between two Merkle DAGs
pub struct ChangeDetector;

impl ChangeDetector {
    /// Detect file-level changes between old and new DAGs
    pub fn detect_changes(old_dag: &MerkleDAG, new_dag: &MerkleDAG) -> FileChanges {
        let old_files = old_dag.get_file_hashes();
        let new_files = new_dag.get_file_hashes();

        let old_paths: HashSet<&String> = old_files.keys().collect();
        let new_paths: HashSet<&String> = new_files.keys().collect();

        let added: Vec<String> = new_paths
            .difference(&old_paths)
            .map(|p| (*p).clone())
            .collect();

        let removed: Vec<String> = old_paths
            .difference(&new_paths)
            .map(|p| (*p).clone())
            .collect();

        let mut modified = Vec::new();
        let mut unchanged = Vec::new();

        for path in old_paths.intersection(&new_paths) {
            if old_files[*path] != new_files[*path] {
                modified.push((*path).clone());
            } else {
                unchanged.push((*path).clone());
            }
        }

        FileChanges {
            added,
            removed,
            modified,
            unchanged,
        }
    }

    /// Quick check if anything changed using root hash comparison
    pub fn has_changes(old_dag: &MerkleDAG, new_dag: &MerkleDAG) -> bool {
        old_dag.get_root_hash() != new_dag.get_root_hash()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use std::path::Path;
    use tempfile::TempDir;

    fn build_dag(root: &Path) -> MerkleDAG {
        MerkleDAG::build(root, &["node_modules", ".git"]).unwrap()
    }

    #[test]
    fn test_detect_no_changes() {
        let dir = TempDir::new().unwrap();
        fs::write(dir.path().join("file.txt"), "hello").unwrap();

        let dag1 = build_dag(dir.path());
        let dag2 = build_dag(dir.path());

        let changes = ChangeDetector::detect_changes(&dag1, &dag2);
        assert!(!changes.has_changes());
        assert_eq!(changes.unchanged.len(), 1);
    }

    #[test]
    fn test_detect_added_file() {
        let dir = TempDir::new().unwrap();
        fs::write(dir.path().join("file1.txt"), "hello").unwrap();
        let dag1 = build_dag(dir.path());

        fs::write(dir.path().join("file2.txt"), "world").unwrap();
        let dag2 = build_dag(dir.path());

        let changes = ChangeDetector::detect_changes(&dag1, &dag2);
        assert!(changes.has_changes());
        assert_eq!(changes.added.len(), 1);
        assert!(changes.added[0].contains("file2.txt"));
    }

    #[test]
    fn test_detect_removed_file() {
        let dir = TempDir::new().unwrap();
        fs::write(dir.path().join("file1.txt"), "hello").unwrap();
        fs::write(dir.path().join("file2.txt"), "world").unwrap();
        let dag1 = build_dag(dir.path());

        fs::remove_file(dir.path().join("file2.txt")).unwrap();
        let dag2 = build_dag(dir.path());

        let changes = ChangeDetector::detect_changes(&dag1, &dag2);
        assert!(changes.has_changes());
        assert_eq!(changes.removed.len(), 1);
    }

    #[test]
    fn test_detect_modified_file() {
        let dir = TempDir::new().unwrap();
        fs::write(dir.path().join("file.txt"), "original").unwrap();
        let dag1 = build_dag(dir.path());

        fs::write(dir.path().join("file.txt"), "modified").unwrap();
        let dag2 = build_dag(dir.path());

        let changes = ChangeDetector::detect_changes(&dag1, &dag2);
        assert!(changes.has_changes());
        assert_eq!(changes.modified.len(), 1);
    }

    #[test]
    fn test_quick_change_check() {
        let dir = TempDir::new().unwrap();
        fs::write(dir.path().join("file.txt"), "hello").unwrap();

        let dag1 = build_dag(dir.path());
        let dag2 = build_dag(dir.path());
        assert!(!ChangeDetector::has_changes(&dag1, &dag2));

        fs::write(dir.path().join("file.txt"), "changed").unwrap();
        let dag3 = build_dag(dir.path());
        assert!(ChangeDetector::has_changes(&dag1, &dag3));
    }
}