zeptoclaw 0.7.2

Ultra-lightweight personal AI assistant
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

//! Quota status and reset command handler.

use anyhow::Result;

use zeptoclaw::providers::QuotaStore;

use super::QuotaSubcommand;

/// Handle `zeptoclaw quota` subcommands.
pub(crate) fn cmd_quota(action: QuotaSubcommand) -> Result<()> {
    match action {
        QuotaSubcommand::Status => {
            let store = QuotaStore::load_or_default();
            let snapshot = store.snapshot();

            if snapshot.is_empty() {
                println!("No quota usage recorded.");
                return Ok(());
            }

            // Print header
            println!(
                "{:<16} {:<12} {:<16} {:<16}",
                "Provider", "Period", "Cost Used", "Tokens Used"
            );
            println!("{}", "-".repeat(62));

            // Sort by provider name for deterministic output
            let mut entries: Vec<_> = snapshot.iter().collect();
            entries.sort_by_key(|(name, _)| name.as_str());

            for (name, usage) in entries {
                println!(
                    "{:<16} {:<12} {:<16} {:<16}",
                    name,
                    usage.period_key,
                    format!("${:.2}", usage.cost_usd),
                    usage.tokens,
                );
            }
        }
        QuotaSubcommand::Reset { provider } => {
            let store = QuotaStore::load_or_default();
            match provider {
                Some(name) => {
                    let normalized = name.trim().to_lowercase();
                    store.reset_provider(&normalized);
                    println!("Reset quota usage for: {}", normalized);
                }
                None => {
                    store.reset_all();
                    println!("Reset all quota usage.");
                }
            }
        }
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use tempfile::TempDir;
    use zeptoclaw::providers::{quota::QuotaPeriod, QuotaStore};

    #[test]
    fn test_quota_status_empty() {
        let dir = TempDir::new().unwrap();
        let store = QuotaStore::load_from_dir(dir.path());
        let snap = store.snapshot();
        assert!(snap.is_empty(), "fresh store should be empty");
    }

    #[test]
    fn test_quota_reset_all() {
        let dir = TempDir::new().unwrap();
        let store = QuotaStore::load_from_dir(dir.path());

        store.record("test-anthropic", &QuotaPeriod::Monthly, 10.0, 1_000);
        store.record("test-openai", &QuotaPeriod::Monthly, 5.0, 500);

        {
            let snap = store.snapshot();
            assert!(snap.contains_key("test-anthropic"), "should be recorded");
            assert!(snap.contains_key("test-openai"), "should be recorded");
        }

        store.reset_all();

        let snap = store.snapshot();
        assert!(
            !snap.contains_key("test-anthropic"),
            "should be gone after reset_all"
        );
        assert!(
            !snap.contains_key("test-openai"),
            "should be gone after reset_all"
        );
    }
}