codemem-engine 0.19.0

Domain logic engine for Codemem: indexing, hooks, watching, scoring, recall, consolidation
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

use super::*;

#[test]
fn test_is_watchable() {
    assert!(is_watchable(Path::new("src/main.rs")));
    assert!(is_watchable(Path::new("index.ts")));
    assert!(is_watchable(Path::new("app.py")));
    assert!(is_watchable(Path::new("main.go")));
    assert!(!is_watchable(Path::new("image.png")));
    assert!(!is_watchable(Path::new("binary.exe")));
}

#[test]
fn test_should_ignore_without_gitignore() {
    assert!(should_ignore(
        Path::new("project/node_modules/foo/bar.js"),
        None,
        false,
    ));
    assert!(should_ignore(
        Path::new("project/target/debug/build.rs"),
        None,
        false,
    ));
    assert!(should_ignore(Path::new(".git/config"), None, false));
    assert!(!should_ignore(Path::new("src/main.rs"), None, false));
    assert!(!should_ignore(Path::new("lib/utils.ts"), None, false));
}

#[test]
fn test_should_ignore_with_gitignore() {
    let dir = tempfile::tempdir().unwrap();
    let gitignore_path = dir.path().join(".gitignore");
    std::fs::write(&gitignore_path, "*.log\nsecrets/\n").unwrap();

    let gi = build_gitignore(dir.path()).unwrap();

    // Matches .gitignore pattern (*.log)
    assert!(should_ignore(
        &dir.path().join("debug.log"),
        Some(&gi),
        false
    ));

    // Matches .gitignore pattern (secrets/) -- also caught by hardcoded fallback check
    // The gitignore matcher matches against paths under the root.
    // For directory patterns, the path must be checked as a directory.
    assert!(should_ignore(
        &dir.path().join("secrets/key.txt"),
        Some(&gi),
        false,
    ));

    // Matches hardcoded IGNORE_DIRS via the fallback component check
    assert!(should_ignore(
        &dir.path().join("node_modules/foo.js"),
        Some(&gi),
        false,
    ));

    // Not ignored
    assert!(!should_ignore(
        &dir.path().join("src/main.rs"),
        Some(&gi),
        false
    ));
}

#[test]
fn test_build_gitignore_without_file() {
    let dir = tempfile::tempdir().unwrap();
    // No .gitignore file exists
    let gi = build_gitignore(dir.path());
    // Should still return Some since we add fallback patterns
    assert!(gi.is_some());

    // Hardcoded dirs are still caught by the should_ignore fallback
    let gi = gi.unwrap();
    assert!(should_ignore(
        &dir.path().join("node_modules/foo.js"),
        Some(&gi),
        false,
    ));
}

#[test]
fn test_detect_language() {
    assert_eq!(detect_language(Path::new("main.rs")), Some("rust"));
    assert_eq!(detect_language(Path::new("app.tsx")), Some("typescript"));
    assert_eq!(detect_language(Path::new("script.py")), Some("python"));
    assert_eq!(detect_language(Path::new("main.go")), Some("go"));
    assert_eq!(detect_language(Path::new("readme.md")), None);
}

#[test]
fn test_new_file_emits_file_created() {
    let dir = tempfile::tempdir().unwrap();
    let watcher = FileWatcher::new(dir.path()).unwrap();
    let rx = watcher.receiver();

    // Create a new watchable file after the watcher starts
    let file_path = dir.path().join("hello.rs");
    std::fs::write(&file_path, "fn main() {}").unwrap();

    // Wait for the debounced event (50ms debounce + margin)
    let event = rx.recv_timeout(Duration::from_secs(2));
    assert!(event.is_ok(), "expected a watch event for new file");
    assert!(
        matches!(event.unwrap(), WatchEvent::FileCreated(_)),
        "new file should emit FileCreated"
    );
}

#[test]
fn test_modified_file_emits_file_changed() {
    let dir = tempfile::tempdir().unwrap();

    // Create file before the watcher starts so it's not "new"
    let file_path = dir.path().join("existing.rs");
    std::fs::write(&file_path, "fn main() {}").unwrap();

    let watcher = FileWatcher::new(dir.path()).unwrap();
    let rx = watcher.receiver();

    // First touch: watcher hasn't seen it yet, so this is FileCreated
    std::fs::write(&file_path, "fn main() { println!(); }").unwrap();
    let first = rx.recv_timeout(Duration::from_secs(2));
    assert!(first.is_ok(), "expected event for first write");
    assert!(matches!(first.unwrap(), WatchEvent::FileCreated(_)));

    // Second touch: watcher has now seen it, so this should be FileChanged
    std::thread::sleep(Duration::from_millis(100));
    std::fs::write(&file_path, "fn main() { eprintln!(); }").unwrap();
    let second = rx.recv_timeout(Duration::from_secs(2));
    assert!(second.is_ok(), "expected event for second write");
    assert!(
        matches!(second.unwrap(), WatchEvent::FileChanged(_)),
        "subsequent modification should emit FileChanged"
    );
}