zeph 0.18.3

Lightweight AI agent with hybrid inference, skills-first architecture, and multi-channel I/O
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

// SPDX-FileCopyrightText: 2026 Andrei G <bug-ops>
// SPDX-License-Identifier: MIT OR Apache-2.0

use zeph_llm::router::thompson::ThompsonState;

use crate::cli::RouterCommand;

/// Handle `zeph router <subcommand>`.
///
/// # Errors
///
/// Returns an error if state file I/O fails.
pub(crate) fn handle_router_command(cmd: RouterCommand) -> anyhow::Result<()> {
    match cmd {
        RouterCommand::Stats { state_path } => {
            let path = state_path.unwrap_or_else(ThompsonState::default_path);
            let thompson_state = ThompsonState::load(&path);
            let stats = thompson_state.provider_stats();
            if stats.is_empty() {
                println!("No Thompson state found at: {}", path.display());
                println!("(File missing or empty — uniform priors will be used on next run)");
            } else {
                println!("Thompson Sampling state: {}", path.display());
                println!(
                    "{:<30} {:>8} {:>8} {:>12}",
                    "Provider", "alpha", "beta", "Mean%"
                );
                println!("{}", "-".repeat(62));
                let total_mean: f64 = stats.iter().map(|(_, a, b)| a / (a + b)).sum();
                for (name, alpha, beta) in &stats {
                    let mean = alpha / (alpha + beta);
                    let pct = if total_mean > 0.0 {
                        mean / total_mean * 100.0
                    } else {
                        0.0
                    };
                    println!("{name:<30} {alpha:>8.2} {beta:>8.2} {pct:>11.1}%");
                }
            }
            Ok(())
        }
        RouterCommand::Reset { state_path } => {
            let path = state_path.unwrap_or_else(ThompsonState::default_path);
            match std::fs::remove_file(&path) {
                Ok(()) => println!("Thompson state reset: {}", path.display()),
                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                    println!("No state file at: {} (nothing to reset)", path.display());
                }
                Err(e) => return Err(e.into()),
            }
            Ok(())
        }
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use super::*;

    #[test]
    fn stats_missing_file_succeeds() {
        let cmd = RouterCommand::Stats {
            state_path: Some(PathBuf::from("/tmp/zeph-router-test-nonexistent.json")),
        };
        // Should not error — missing file is treated as empty state.
        assert!(handle_router_command(cmd).is_ok());
    }

    #[test]
    fn reset_missing_file_succeeds() {
        let cmd = RouterCommand::Reset {
            state_path: Some(PathBuf::from("/tmp/zeph-router-test-nonexistent.json")),
        };
        // Should not error — ENOENT is handled gracefully.
        assert!(handle_router_command(cmd).is_ok());
    }

    #[test]
    fn reset_existing_file_removes_it() {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("state.json");

        let mut state = ThompsonState::default();
        state.update("p", true);
        state.save(&path).unwrap();
        assert!(path.exists());

        let cmd = RouterCommand::Reset {
            state_path: Some(path.clone()),
        };
        handle_router_command(cmd).unwrap();
        assert!(!path.exists(), "state file must be deleted after reset");
    }
}