linear-cli 0.3.22

A powerful CLI for Linear.app - manage issues, projects, cycles, and more from your terminal
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

use anyhow::Result;
use clap::Subcommand;
use colored::Colorize;
use tabled::{Table, Tabled};

use crate::cache::{Cache, CacheType};

#[derive(Subcommand)]
pub enum CacheCommands {
    /// Clear all cached data
    Clear {
        /// Only clear a specific cache type (teams, users, statuses, labels, projects)
        #[arg(short, long)]
        r#type: Option<String>,
    },
    /// Show cache status and sizes
    Status,
}

#[derive(Tabled)]
struct CacheStatusRow {
    #[tabled(rename = "Type")]
    cache_type: String,
    #[tabled(rename = "Valid")]
    valid: String,
    #[tabled(rename = "Age")]
    age: String,
    #[tabled(rename = "Size")]
    size: String,
    #[tabled(rename = "Items")]
    items: String,
}

pub async fn handle(cmd: CacheCommands) -> Result<()> {
    match cmd {
        CacheCommands::Clear { r#type } => clear_cache(r#type).await,
        CacheCommands::Status => show_status().await,
    }
}

async fn clear_cache(cache_type: Option<String>) -> Result<()> {
    let cache = Cache::new()?;

    if let Some(type_str) = cache_type {
        let cache_type = match type_str.to_lowercase().as_str() {
            "teams" => CacheType::Teams,
            "users" => CacheType::Users,
            "statuses" | "states" => CacheType::Statuses,
            "labels" => CacheType::Labels,
            "projects" => CacheType::Projects,
            _ => {
                anyhow::bail!(
                    "Unknown cache type: '{}'. Valid types: teams, users, statuses, labels, projects",
                    type_str
                );
            }
        };
        cache.clear_type(cache_type)?;
        println!(
            "{} Cleared {} cache",
            "+".green(),
            cache_type.display_name()
        );
    } else {
        cache.clear_all()?;
        println!("{} Cleared all caches", "+".green());
    }

    Ok(())
}

async fn show_status() -> Result<()> {
    let cache = Cache::new()?;
    let statuses = cache.status();

    println!("{}", "Cache Status".bold());
    println!("{}", "-".repeat(50));

    let rows: Vec<CacheStatusRow> = statuses
        .iter()
        .map(|s| CacheStatusRow {
            cache_type: s.cache_type.display_name().to_string(),
            valid: if s.valid {
                "Yes".green().to_string()
            } else {
                "No".dimmed().to_string()
            },
            age: s.age_display(),
            size: s.size_display(),
            items: s
                .item_count
                .map(|c| c.to_string())
                .unwrap_or_else(|| "-".to_string()),
        })
        .collect();

    let table = Table::new(rows).to_string();
    println!("{}", table);

    // Summary
    let valid_count = statuses.iter().filter(|s| s.valid).count();
    let total_size: u64 = statuses.iter().filter_map(|s| s.size_bytes).sum();

    println!();
    println!("{} of {} caches valid", valid_count, CacheType::all().len());
    if total_size > 0 {
        let size_display = if total_size < 1024 {
            format!("{} B", total_size)
        } else if total_size < 1024 * 1024 {
            format!("{:.1} KB", total_size as f64 / 1024.0)
        } else {
            format!("{:.1} MB", total_size as f64 / (1024.0 * 1024.0))
        };
        println!("Total cache size: {}", size_display);
    }

    Ok(())
}