ctxpack 0.1.0

Configuration-driven source packing for LLM context, with a versioning protocol for incremental patch/replace
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

use anyhow::Result;
use std::path::{Path, PathBuf};

use super::state::IndexState;

pub struct SnapshotCache {
    pub cache_dir: PathBuf,
}

impl SnapshotCache {
    pub fn new(cache_dir: &Path) -> Self {
        SnapshotCache { cache_dir: cache_dir.to_path_buf() }
    }

    fn snapshot_path(&self, fid: u32, generation: u32) -> PathBuf {
        self.cache_dir
            .join("snapshots")
            .join(fid.to_string())
            .join(format!("gen{}.raw", generation))
    }

    pub fn store_snapshot(&self, fid: u32, generation: u32, raw_content: &str) -> Result<()> {
        let path = self.snapshot_path(fid, generation);
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }
        std::fs::write(&path, raw_content)?;
        Ok(())
    }

    pub fn load_snapshot(&self, fid: u32, generation: u32) -> Result<Option<String>> {
        let path = self.snapshot_path(fid, generation);
        if !path.exists() {
            return Ok(None);
        }
        let content = std::fs::read_to_string(&path)?;
        Ok(Some(content))
    }

    pub fn cleanup(&self, fid: u32, retain_last_n: u32) -> Result<()> {
        let dir = self.cache_dir.join("snapshots").join(fid.to_string());
        if !dir.exists() {
            return Ok(());
        }

        let mut gens: Vec<u32> = Vec::new();
        for entry in std::fs::read_dir(&dir)? {
            let entry = entry?;
            let name = entry.file_name();
            let name = name.to_string_lossy();
            if let Some(rest) = name.strip_prefix("gen")
                && let Some(n_str) = rest.strip_suffix(".raw")
                && let Ok(n) = n_str.parse::<u32>()
            {
                gens.push(n);
            }
        }

        gens.sort();
        let to_delete = if gens.len() > retain_last_n as usize {
            &gens[..gens.len() - retain_last_n as usize]
        } else {
            &[]
        };

        for generation in to_delete {
            let path = self.snapshot_path(fid, *generation);
            if path.exists() {
                std::fs::remove_file(&path)?;
            }
        }

        Ok(())
    }

    pub fn cleanup_all(&self, index: &IndexState, retain_last_n: u32) -> Result<()> {
        for entry in index.files.values() {
            self.cleanup(entry.fid, retain_last_n)?;
        }
        Ok(())
    }
}

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

    #[test]
    fn test_store_load_round_trip() {
        let dir = TempDir::new().unwrap();
        let cache = SnapshotCache::new(dir.path());
        cache.store_snapshot(1, 0, "hello world").unwrap();
        let loaded = cache.load_snapshot(1, 0).unwrap();
        assert_eq!(loaded, Some("hello world".to_string()));
    }

    #[test]
    fn test_load_missing_returns_none() {
        let dir = TempDir::new().unwrap();
        let cache = SnapshotCache::new(dir.path());
        let loaded = cache.load_snapshot(99, 0).unwrap();
        assert_eq!(loaded, None);
    }

    #[test]
    fn test_cleanup_retains_last_n() {
        let dir = TempDir::new().unwrap();
        let cache = SnapshotCache::new(dir.path());
        for generation in 0..5 {
            cache.store_snapshot(1, generation, &format!("gen{}", generation)).unwrap();
        }
        cache.cleanup(1, 3).unwrap();
        assert_eq!(cache.load_snapshot(1, 0).unwrap(), None);
        assert_eq!(cache.load_snapshot(1, 1).unwrap(), None);
        assert!(cache.load_snapshot(1, 2).unwrap().is_some());
        assert!(cache.load_snapshot(1, 3).unwrap().is_some());
        assert!(cache.load_snapshot(1, 4).unwrap().is_some());
    }

    #[test]
    fn test_cleanup_all() {
        let dir = TempDir::new().unwrap();
        let cache = SnapshotCache::new(dir.path());
        for generation in 0..3 {
            cache.store_snapshot(1, generation, "content").unwrap();
        }
        let mut index = IndexState::default();
        index.allocate_fid("file.rs", "file.rs");
        cache.cleanup_all(&index, 1).unwrap();
        assert_eq!(cache.load_snapshot(1, 0).unwrap(), None);
        assert_eq!(cache.load_snapshot(1, 1).unwrap(), None);
        assert!(cache.load_snapshot(1, 2).unwrap().is_some());
    }
}