lean-ctx 3.9.19

Context Runtime for AI Agents with CCP. 79 MCP tools, 10 read modes, 95+ compression patterns, cross-session memory (CCP), persistent AI knowledge with temporal facts + contradiction detection, multi-agent context sharing, LITM-aware positioning, AAAK compact format, adaptive compression with Thompson Sampling bandits. Supports 24+ AI tools. Reduces LLM token consumption by up to 99%.
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

//! Predictive context pre-loading (OSS stub).
//!
//! Enterprise pre-caches files based on task triage predictions.
//! OSS: no-op (no prefetching).

/// Warms the cache for predicted paths (OSS: no-op).
pub fn warm_predictions<T>(_paths: &[String], _cache: Option<&T>) {}

/// Plans prefetch after triage (OSS: no-op).
pub fn plan_after_triage(_task_class: &str) {}

/// Count of successfully warmed predictions (OSS: 0).
pub fn warmed_count() -> u64 {
    0
}

/// Count of skipped predictions (OSS: 0).
pub fn skipped_count() -> u64 {
    0
}

/// An entry in the prefetch plan.
#[derive(Debug, Clone)]
pub struct PrefetchEntry {
    pub path: String,
    pub score: f64,
}

/// A prefetch plan containing predicted files.
#[derive(Debug, Clone, Default)]
pub struct PrefetchPlan {
    pub files: Vec<PrefetchEntry>,
}

/// File trajectory tracker (OSS stub).
pub struct FileTrajectory {
    paths: Vec<(String, u32)>,
    capacity: usize,
}

impl FileTrajectory {
    pub fn new(capacity: usize) -> Self {
        Self {
            paths: Vec::new(),
            capacity,
        }
    }

    pub fn record(&mut self, path: &str) {
        if let Some(entry) = self.paths.iter_mut().find(|(p, _)| p == path) {
            entry.1 += 1;
        } else {
            if self.paths.len() >= self.capacity {
                self.paths.remove(0);
            }
            self.paths.push((path.to_owned(), 1));
        }
    }

    pub fn predict(&self, top_k: usize) -> Vec<(String, f64)> {
        let mut scored: Vec<(String, f64)> = self
            .paths
            .iter()
            .map(|(path, count)| (path.clone(), *count as f64))
            .collect();
        scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        scored.truncate(top_k);
        scored
    }
}

/// Builds a prefetch plan from trajectory data (OSS: basic frequency-based).
pub fn build_prefetch_plan(
    trajectory: &FileTrajectory,
    _exclude: &[String],
    top_k: usize,
    _min_score: f64,
) -> PrefetchPlan {
    let files = trajectory
        .predict(top_k)
        .into_iter()
        .map(|(path, score)| PrefetchEntry { path, score })
        .collect();
    PrefetchPlan { files }
}

/// Records a file read for trajectory learning (OSS: no-op).
pub fn record_file_read(_path: &str) {}

/// Checks if a path was predicted by the prefetch engine (OSS: always false).
pub fn is_prefetch_prediction(_path: &str) -> bool {
    false
}