lc-cli 0.1.3

LLM Client - A fast Rust-based LLM CLI tool with provider management and chat sessions
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Usage statistics commands

use crate::analytics::usage_stats::{display_usage_overview, BarChart, UsageAnalyzer};
use crate::cli::UsageCommands;
use anyhow::Result;
use colored::Colorize;

/// Handle usage-related commands
pub async fn handle(
    command: Option<UsageCommands>,
    days: Option<u64>,
    tokens_only: bool,
    requests_only: bool,
    limit: Option<usize>,
) -> Result<()> {
    // Convert types to match what the analytics module expects
    let days_u32 = days.map(|d| d as u32);
    let limit_val = limit.unwrap_or(10);

    let analyzer = UsageAnalyzer::new()?;
    let stats = analyzer.get_usage_stats(days_u32)?;

    if stats.total_requests == 0 {
        println!("{} No usage data found", "ℹī¸".blue());
        if days.is_some() {
            println!("Try expanding the time range or check if you have any logged interactions.");
        }
        return Ok(());
    }

    match command {
        Some(UsageCommands::Daily { count }) => {
            let value_type = determine_value_type(tokens_only, requests_only);

            BarChart::render_time_series(
                "📅 Daily Usage",
                &stats.daily_usage,
                value_type,
                50,
                count.min(limit_val),
            );
        }
        Some(UsageCommands::Weekly { count }) => {
            let value_type = determine_value_type(tokens_only, requests_only);

            BarChart::render_time_series(
                "📊 Weekly Usage",
                &stats.weekly_usage,
                value_type,
                50,
                count.min(limit_val),
            );
        }
        Some(UsageCommands::Monthly { count }) => {
            let value_type = determine_value_type(tokens_only, requests_only);

            BarChart::render_time_series(
                "📈 Monthly Usage",
                &stats.monthly_usage,
                value_type,
                50,
                count.min(limit_val),
            );
        }
        Some(UsageCommands::Yearly { count }) => {
            let value_type = determine_value_type(tokens_only, requests_only);

            BarChart::render_time_series(
                "📊 Yearly Usage",
                &stats.yearly_usage,
                value_type,
                50,
                count.min(limit_val),
            );
        }
        Some(UsageCommands::Models { count }) => {
            let value_type = determine_value_type(tokens_only, requests_only);

            BarChart::render_horizontal(
                "🤖 Top Models by Usage",
                &stats.model_usage,
                value_type,
                50,
                count.min(limit_val),
            );
        }
        None => {
            // Default: show overview and top charts
            display_usage_overview(&stats);

            if !tokens_only && !requests_only {
                // Show both tokens and requests by default
                BarChart::render_horizontal(
                    "🤖 Top Models by Token Usage",
                    &stats.model_usage,
                    "tokens",
                    50,
                    limit_val.min(5),
                );

                BarChart::render_time_series(
                    "📅 Recent Daily Usage (Tokens)",
                    &stats.daily_usage,
                    "tokens",
                    50,
                    limit_val.min(14),
                );
            } else if tokens_only {
                BarChart::render_horizontal(
                    "🤖 Top Models by Token Usage",
                    &stats.model_usage,
                    "tokens",
                    50,
                    limit_val.min(10),
                );

                BarChart::render_time_series(
                    "📅 Recent Daily Token Usage",
                    &stats.daily_usage,
                    "tokens",
                    50,
                    limit_val.min(14),
                );
            } else if requests_only {
                BarChart::render_horizontal(
                    "🤖 Top Models by Request Count",
                    &stats.model_usage,
                    "requests",
                    50,
                    limit_val.min(10),
                );

                BarChart::render_time_series(
                    "📅 Recent Daily Request Count",
                    &stats.daily_usage,
                    "requests",
                    50,
                    limit_val.min(14),
                );
            }
        }
    }

    Ok(())
}

/// Determine which value type to display based on flags
fn determine_value_type(tokens_only: bool, requests_only: bool) -> &'static str {
    if tokens_only {
        "tokens"
    } else if requests_only {
        "requests"
    } else {
        "tokens" // Default to tokens when neither flag is set
    }
}