cacher 0.4.1

A CLI tool for caching command outputs
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

use cacher::CommandCache;
use clap::{Parser, Subcommand};
use std::time::{Duration, SystemTime};

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
    /// Run a command with caching
    Run {
        /// The command to run
        #[arg(required = true)]
        command: String,
        
        /// Arguments for the command
        #[arg(num_args = 0..)]
        args: Vec<String>,
        
        /// Time-to-live for cache in seconds (default: no TTL)
        #[arg(short, long)]
        ttl: Option<u64>,
        
        /// Force execution (ignore cache)
        #[arg(short, long)]
        force: bool,
    },
    
    /// List cached commands
    List,
    
    /// Clear the cache
    Clear {
        /// Clear all cached commands
        #[arg(short, long)]
        all: bool,
        
        /// Clear a specific command
        #[arg(short, long)]
        command: Option<String>,
    },
    
    /// Get the UUID (hash) for a command
    Hash {
        /// The command to get the hash for
        #[arg(required = true)]
        command: String,
        
        /// Arguments for the command
        #[arg(num_args = 0..)]
        args: Vec<String>,
    },
}

fn main() {
    let cli = Cli::parse();
    let mut cache = CommandCache::new();
    
    match &cli.command {
        Some(Commands::Run { command, args, ttl, force }) => {
            // Combine command and args into a single string
            let full_command = format!("{} {}", command, args.join(" ")).trim().to_string();
            
            // Convert TTL to Duration if provided
            let ttl_duration = ttl.map(|seconds| Duration::from_secs(seconds));
            
            match cache.execute_and_cache_with_artifacts(&full_command, ttl_duration, *force) {
                Ok(output) => println!("{}", output),
                Err(e) => eprintln!("Error executing command: {}", e),
            }
        },
        Some(Commands::List) => {
            match cache.list_cached_commands() {
                Ok(entries) => {
                    if entries.is_empty() {
                        println!("No cached commands found.");
                    } else {
                        println!("Cached commands:");
                        for (i, (command, timestamp)) in entries.iter().enumerate() {
                            let age = format_time_ago(timestamp);
                            let hash = cache.generate_id(command);
                            println!("{}. {} ({})", i + 1, command, age);
                            println!("   Hash: {}", hash);
                        }
                    }
                },
                Err(e) => eprintln!("Error listing cache: {}", e),
            }
        },
        Some(Commands::Clear { all, command }) => {
            if *all {
                match cache.clear_cache(None) {
                    Ok(_) => println!("Cleared all cached commands."),
                    Err(e) => eprintln!("Error clearing cache: {}", e),
                }
            } else if let Some(cmd) = command {
                match cache.clear_cache(Some(cmd)) {
                    Ok(_) => println!("Cleared cache for command: {}", cmd),
                    Err(e) => eprintln!("Error clearing cache: {}", e),
                }
            } else {
                println!("Please specify --all to clear all cache or --command to clear a specific command.");
            }
        },
        Some(Commands::Hash { command, args }) => {
            // Combine command and args into a single string
            let full_command = format!("{} {}", command, args.join(" ")).trim().to_string();
            
            // Generate and display the hash
            let hash = cache.generate_id(&full_command);
            println!("{}", hash);
        },
        None => {
            println!("Cacher CLI - A tool for caching command outputs");
            println!("Use --help for usage information");
        }
    }
}

fn format_time_ago(timestamp: &SystemTime) -> String {
    if let Ok(duration) = SystemTime::now().duration_since(*timestamp) {
        if duration.as_secs() < 60 {
            format!("{} seconds ago", duration.as_secs())
        } else if duration.as_secs() < 3600 {
            format!("{} minutes ago", duration.as_secs() / 60)
        } else if duration.as_secs() < 86400 {
            format!("{} hours ago", duration.as_secs() / 3600)
        } else {
            format!("{} days ago", duration.as_secs() / 86400)
        }
    } else {
        "unknown time".to_string()
    }
}