eli 0.5.0

Ease Lives Instantly — hook-first AI agent framework with multi-channel support
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

//! Tests for the subagent subsystem: tracker, worktree, fallback.

#[cfg(test)]
mod tracker_tests {
    use crate::builtin::subagent::tracker::{AgentResult, AgentTracker};

    #[tokio::test]
    async fn test_register_and_list() {
        let tracker = AgentTracker::new();
        assert!(
            tracker
                .register(
                    "a1",
                    Some("sh-1".into()),
                    "general",
                    "test task",
                    "/tmp",
                    "claude"
                )
                .await
        );
        let list = tracker.list().await;
        assert_eq!(list.len(), 1);
        assert_eq!(list[0].0, "a1");
        assert!(list[0].1.running);
    }

    #[tokio::test]
    async fn test_complete_and_get_result() {
        let tracker = AgentTracker::new();
        tracker
            .register("a2", None, "explore", "search", "/tmp", "codex")
            .await;
        tracker
            .complete(
                "a2",
                AgentResult {
                    exit_code: Some(0),
                    output: "found 3 matches".into(),
                    artifacts: "(no changes)".into(),
                    duration_ms: 1234,
                },
            )
            .await;
        let result = tracker.get_result("a2").await.expect("result should exist");
        assert_eq!(result.exit_code, Some(0));
        assert!(result.output.contains("found"));
    }

    #[tokio::test]
    async fn test_running_count() {
        let tracker = AgentTracker::new();
        tracker
            .register("a3", None, "general", "t1", "/", "claude")
            .await;
        tracker
            .register("a4", None, "general", "t2", "/", "claude")
            .await;
        assert_eq!(tracker.running_count().await, 2);

        tracker
            .complete(
                "a3",
                AgentResult {
                    exit_code: Some(0),
                    output: String::new(),
                    artifacts: String::new(),
                    duration_ms: 100,
                },
            )
            .await;
        assert_eq!(tracker.running_count().await, 1);
    }

    #[tokio::test]
    async fn test_evict_completed() {
        let tracker = AgentTracker::new();
        tracker
            .register("a5", None, "general", "old", "/", "claude")
            .await;
        tracker
            .complete(
                "a5",
                AgentResult {
                    exit_code: Some(0),
                    output: String::new(),
                    artifacts: String::new(),
                    duration_ms: 0,
                },
            )
            .await;

        // With a zero max_age, completed agents should be evicted.
        tracker.evict_completed(std::time::Duration::ZERO).await;
        assert!(tracker.get_result("a5").await.is_none());
    }

    #[tokio::test]
    async fn test_nonexistent_result_returns_none() {
        let tracker = AgentTracker::new();
        assert!(tracker.get_result("does-not-exist").await.is_none());
    }
}

#[cfg(test)]
mod tool_tests {
    use super::super::tracker;

    #[test]
    fn test_global_tracker_accessible() {
        let _t = tracker::agent_tracker();
    }
}