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

//! Domain-specific error types for better error handling
//! 
//! This module provides structured error types to replace unsafe unwrap() and expect() calls
//! throughout the codebase, improving reliability and debuggability.

use thiserror::Error;

/// Main error type for CLI operations
#[derive(Debug, Error)]
pub enum CliError {
    #[error("Provider not found: {0}")]
    ProviderNotFound(String),
    
    #[error("Provider '{0}' has no API key configured")]
    MissingApiKey(String),
    
    #[error("Invalid configuration: {0}")]
    InvalidConfig(String),
    
    #[error("Model not found: {0}")]
    ModelNotFound(String),
    
    #[error("Cache error: {0}")]
    CacheError(String),
    
    #[error("Database error: {0}")]
    Database(#[from] rusqlite::Error),
    
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("JSON parsing error: {0}")]
    Json(#[from] serde_json::Error),
    
    #[error("HTTP request failed: {0}")]
    Http(String),
    
    #[error("Session error: {0}")]
    Session(String),
    
    #[error("MCP error: {0}")]
    Mcp(String),
    
    #[error("Authentication error: {0}")]
    Auth(String),
    
    #[error("Template processing error: {0}")]
    Template(String),
}

/// Error type for cache operations
#[derive(Debug, Error)]
pub enum CacheError {
    #[error("Cache not initialized")]
    NotInitialized,
    
    #[error("Failed to load cache: {0}")]
    LoadFailed(String),
    
    #[error("Failed to save cache: {0}")]
    SaveFailed(String),
    
    #[error("Cache data corrupted")]
    Corrupted,
}

/// Error type for provider operations
#[derive(Debug, Error)]
pub enum ProviderError {
    #[error("Provider '{0}' not configured")]
    NotConfigured(String),
    
    #[error("API key missing for provider '{0}'")]
    MissingApiKey(String),
    
    #[error("Invalid endpoint URL: {0}")]
    InvalidEndpoint(String),
    
    #[error("HTTP client creation failed: {0}")]
    ClientCreation(String),
    
    #[error("Request failed: {0}")]
    RequestFailed(String),
}

/// Error type for database operations
#[derive(Debug, Error)]
pub enum DatabaseError {
    #[error("Connection pool exhausted")]
    PoolExhausted,
    
    #[error("Connection not available")]
    NoConnection,
    
    #[error("Query failed: {0}")]
    QueryFailed(String),
    
    #[error("Transaction failed: {0}")]
    TransactionFailed(String),
    
    #[error("Database operation failed: {0}")]
    OperationFailed(#[from] rusqlite::Error),
}

/// Result type alias using our main error type
pub type CliResult<T> = Result<T, CliError>;

/// Result type alias for cache operations
pub type CacheResult<T> = Result<T, CacheError>;

/// Result type alias for provider operations
pub type ProviderResult<T> = Result<T, ProviderError>;

/// Result type alias for database operations
pub type DatabaseResult<T> = Result<T, DatabaseError>;

/// Extension trait for Option types to convert to Results with context
pub trait OptionExt<T> {
    /// Convert Option to Result with a context message
    fn ok_or_context<C>(self, context: C) -> CliResult<T>
    where
        C: std::fmt::Display;
}

impl<T> OptionExt<T> for Option<T> {
    fn ok_or_context<C>(self, context: C) -> CliResult<T>
    where
        C: std::fmt::Display,
    {
        self.ok_or_else(|| CliError::InvalidConfig(context.to_string()))
    }
}