llman 0.0.79

A tool for managing LLM application rules(prompts) ...
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

use anyhow::Result as _Result;
use thiserror::Error;

#[derive(Debug, Error)]
#[allow(dead_code)]
pub enum LlmanError {
    #[error("Config Error: {message}")]
    Config { message: String },

    #[error("Invalid App Type: {app}")]
    InvalidApp { app: String },

    #[error("Current directory is not a valid project directory")]
    NotProjectDirectory,

    #[error("Cannot generate rules in home directory")]
    HomeDirectoryNotAllowed,

    #[error("Rule file not found: {name}")]
    RuleNotFound { name: String },

    #[error("Custom Error: {0}")]
    Custom(String),

    #[error("IO Error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Inquire Error: {0}")]
    Inquire(#[from] inquire::InquireError),

    #[error("JSON Parse Error: {0}")]
    Json(#[from] serde_json::Error),

    #[error("Glob Pattern Error: {0}")]
    Glob(#[from] glob::GlobError),

    #[error("Glob Pattern Match Error: {0}")]
    GlobPattern(#[from] glob::PatternError),
}

impl LlmanError {
    #[allow(dead_code)]
    pub fn display_localized(&self) -> String {
        match self {
            LlmanError::Config { message } => {
                t!("errors.config_error", message = message).to_string()
            }
            LlmanError::InvalidApp { app } => t!("errors.invalid_app", app = app).to_string(),
            LlmanError::NotProjectDirectory => t!("errors.not_project_directory").to_string(),
            LlmanError::HomeDirectoryNotAllowed => {
                t!("errors.home_directory_not_allowed").to_string()
            }
            LlmanError::RuleNotFound { name } => {
                t!("errors.rule_not_found", name = name).to_string()
            }
            LlmanError::Custom(message) => t!("errors.custom_error", message = message).to_string(),
            LlmanError::Io(error) => t!("errors.io_error", error = error).to_string(),
            LlmanError::Inquire(error) => t!("errors.inquire_error", error = error).to_string(),
            LlmanError::Json(error) => t!("errors.json_error", error = error).to_string(),
            LlmanError::Glob(error) => t!("errors.glob_error", error = error).to_string(),
            LlmanError::GlobPattern(error) => {
                t!("errors.glob_pattern_error", error = error).to_string()
            }
        }
    }
}

pub type Result<T> = _Result<T, LlmanError>;