ai-agent 0.88.0

Idiomatic agent sdk inspired by the claude code source leak
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

use std::collections::VecDeque;

#[derive(Debug, Clone, PartialEq)]
pub struct TurnDiff {
    pub turn_index: usize,
    pub additions: usize,
    pub deletions: usize,
    pub timestamp: u64,
}

pub struct TurnDiffsTracker {
    diffs: VecDeque<TurnDiff>,
    max_history: usize,
}

impl TurnDiffsTracker {
    pub fn new(max_history: usize) -> Self {
        Self {
            diffs: VecDeque::new(),
            max_history,
        }
    }

    pub fn add_diff(&mut self, turn_index: usize, additions: usize, deletions: usize) {
        let diff = TurnDiff {
            turn_index,
            additions,
            deletions,
            timestamp: now_timestamp(),
        };

        self.diffs.push_back(diff);

        while self.diffs.len() > self.max_history {
            self.diffs.pop_front();
        }
    }

    pub fn get_diffs(&self) -> Vec<TurnDiff> {
        self.diffs.iter().cloned().collect()
    }

    pub fn get_latest(&self) -> Option<TurnDiff> {
        self.diffs.back().cloned()
    }

    pub fn get_total_additions(&self) -> usize {
        self.diffs.iter().map(|d| d.additions).sum()
    }

    pub fn get_total_deletions(&self) -> usize {
        self.diffs.iter().map(|d| d.deletions).sum()
    }

    pub fn get_net_change(&self) -> isize {
        let additions = self.get_total_additions() as isize;
        let deletions = self.get_total_deletions() as isize;
        additions - deletions
    }

    pub fn get_turn_count(&self) -> usize {
        self.diffs.len()
    }

    pub fn clear(&mut self) {
        self.diffs.clear();
    }

    pub fn get_turn_diff(&self, turn_index: usize) -> Option<TurnDiff> {
        self.diffs
            .iter()
            .find(|d| d.turn_index == turn_index)
            .cloned()
    }
}

fn now_timestamp() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_millis() as u64)
        .unwrap_or(0)
}

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

    #[test]
    fn test_turn_diffs_tracker() {
        let mut tracker = TurnDiffsTracker::new(10);

        tracker.add_diff(0, 10, 5);
        tracker.add_diff(1, 20, 3);

        assert_eq!(tracker.get_turn_count(), 2);
        assert_eq!(tracker.get_total_additions(), 30);
        assert_eq!(tracker.get_total_deletions(), 8);
    }

    #[test]
    fn test_net_change() {
        let mut tracker = TurnDiffsTracker::new(10);

        tracker.add_diff(0, 10, 5);
        assert_eq!(tracker.get_net_change(), 5);

        tracker.add_diff(1, 3, 10);
        assert_eq!(tracker.get_net_change(), -2);
    }

    #[test]
    fn test_max_history() {
        let mut tracker = TurnDiffsTracker::new(2);

        tracker.add_diff(0, 10, 0);
        tracker.add_diff(1, 10, 0);
        tracker.add_diff(2, 10, 0);

        assert_eq!(tracker.get_turn_count(), 2);
    }
}