pygmy 0.3.0

Ping me — notifications from AI agents (Telegram, Discord)
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

use std::collections::HashMap;
use std::path::PathBuf;

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};

#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Config {
    pub telegram: Option<TelegramConfig>,
    pub discord_webhook: Option<DiscordWebhookConfig>,
    pub ntfy: Option<NtfyConfig>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct TelegramConfig {
    pub enabled: bool,
    pub bot_token: String,
    pub group_id: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct DiscordWebhookConfig {
    pub enabled: bool,
    pub url: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct NtfyConfig {
    pub enabled: bool,
    pub server: String,
    pub topic: String,
    pub token: Option<String>,
}

#[derive(Debug, Default, Serialize, Deserialize)]
pub struct TopicsCache {
    #[serde(default)]
    pub topics: HashMap<String, i64>,
}

fn config_dir() -> Result<PathBuf> {
    let dir = std::env::var("XDG_CONFIG_HOME")
        .ok()
        .map(PathBuf::from)
        .or_else(|| home::home_dir().map(|h| h.join(".config")))
        .context("could not determine home directory")?
        .join("pygmy");
    Ok(dir)
}

fn config_path() -> Result<PathBuf> {
    Ok(config_dir()?.join("config.toml"))
}

fn cache_dir() -> Result<PathBuf> {
    let dir = std::env::var("XDG_CACHE_HOME")
        .ok()
        .map(PathBuf::from)
        .or_else(|| home::home_dir().map(|h| h.join(".cache")))
        .context("could not determine home directory")?
        .join("pygmy");
    Ok(dir)
}

fn topics_path() -> Result<PathBuf> {
    Ok(cache_dir()?.join("topics.toml"))
}

pub fn load_config() -> Result<Config> {
    let path = config_path()?;
    let data = std::fs::read_to_string(&path).with_context(|| {
        format!(
            "could not read config at {}\nRun `pygmy init <backend>` to set up.",
            path.display()
        )
    })?;
    toml::from_str(&data).context("invalid config format")
}

/// Load existing config or return an empty default (for init flows that merge).
pub fn load_config_or_default() -> Config {
    load_config().unwrap_or_default()
}

pub fn save_config(config: &Config) -> Result<()> {
    let path = config_path()?;
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    let data = toml::to_string_pretty(config)?;
    std::fs::write(&path, data)?;
    Ok(())
}

pub fn load_topics() -> TopicsCache {
    topics_path()
        .ok()
        .and_then(|p| std::fs::read_to_string(p).ok())
        .and_then(|d| toml::from_str(&d).ok())
        .unwrap_or_default()
}

pub fn save_topics(cache: &TopicsCache) -> Result<()> {
    let path = topics_path()?;
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    let data = toml::to_string_pretty(cache)?;
    std::fs::write(&path, data)?;
    Ok(())
}

pub fn config_dir_display() -> String {
    config_dir()
        .map(|p| p.display().to_string())
        .unwrap_or_else(|_| "~/.config/pygmy".to_string())
}

pub fn cache_dir_display() -> String {
    cache_dir()
        .map(|p| p.display().to_string())
        .unwrap_or_else(|_| "~/.cache/pygmy".to_string())
}