aaai 0.40.0

Core engine for aaai — audit for asset integrity
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

//! User preferences — persisted in the OS config directory for aaai.
//!
//! | Platform | Path |
//! |---|---|
//! | Linux   | `$XDG_CONFIG_HOME/aaai/prefs.yaml` (default `~/.config/aaai/`) |
//! | macOS   | `~/Library/Application Support/aaai/prefs.yaml` |
//! | Windows | `%APPDATA%\\aaai\\prefs.yaml` |
//!
//! Currently stores the GUI theme selection.  Future preferences
//! (font size, language override, etc.) can be added here without
//! breaking the format because unknown YAML keys are ignored by serde.

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

/// GUI colour theme.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Theme {
    /// iced built-in light palette (default).
    #[default]
    Light,
    /// iced built-in dark palette.
    Dark,
    /// System preference (not yet implemented — falls back to Light).
    System,
    /// High-contrast light theme (snora-design preset, ≥8:1 status contrast).
    #[serde(rename = "high_contrast_light")]
    HighContrastLight,
    /// High-contrast dark theme (snora-design preset, ≥8:1 status contrast).
    #[serde(rename = "high_contrast_dark")]
    HighContrastDark,
}

impl std::fmt::Display for Theme {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Theme::Light  => write!(f, "Light"),
            Theme::Dark   => write!(f, "Dark"),
            Theme::System            => write!(f, "System"),
            Theme::HighContrastLight => write!(f, "High Contrast Light"),
            Theme::HighContrastDark  => write!(f, "High Contrast Dark"),
        }
    }
}

impl Theme {
    /// All user-selectable themes, in display order (RFC 093).
    ///
    /// `System` is excluded until OS dark-mode detection is available
    /// (RFC 093 §5.1 — hiding avoids a visibly broken picker option).
    /// RFC 094 appends `HighContrastLight` and `HighContrastDark` here.
    /// Returns true for the two high-contrast variants.
    pub fn is_high_contrast(self) -> bool {
        matches!(self, Theme::HighContrastLight | Theme::HighContrastDark)
    }

    pub fn choices() -> &'static [Theme] {
        &[Theme::Light, Theme::Dark, Theme::HighContrastLight, Theme::HighContrastDark]
    }
}

/// Persisted user preferences.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct UserPrefs {
    /// Selected GUI theme.
    #[serde(default)]
    pub theme: Theme,

    /// Locale code (e.g. "en", "ja"). Empty string = follow system / fallback.
    /// RFC 036 — previously tracked only in the GUI session; now persisted.
    #[serde(default)]
    pub language: String,

    /// Directory names silently excluded from every audit.
    /// Converted to `<name>/**` glob patterns and prepended to the
    /// `IgnoreRules` before any per-project `.aaaiignore` patterns.
    /// RFC 036 — configurable via the Settings dialog.
    #[serde(default = "default_ignored_dirs")]
    pub global_ignored_dirs: Vec<String>,
}

fn default_ignored_dirs() -> Vec<String> {
    vec![
        ".git".into(),
        "target".into(),
        "node_modules".into(),
        ".DS_Store".into(),
    ]
}

impl UserPrefs {
    fn path() -> anyhow::Result<PathBuf> {
        let base = dirs::config_dir()
            .ok_or_else(|| anyhow::anyhow!("Cannot determine OS config directory"))?
            .join("aaai");
        std::fs::create_dir_all(&base)?;
        Ok(base.join("prefs.yaml"))
    }

    /// Load from the OS config directory.  Returns defaults if the file is absent.
    pub fn load() -> Self {
        match Self::path().and_then(|p| {
            if !p.exists() { return Ok(Self::default()); }
            let text = std::fs::read_to_string(&p)?;
            serde_yaml::from_str(&text).map_err(|e| anyhow::anyhow!(e))
        }) {
            Ok(prefs) => prefs,
            Err(e) => {
                log::warn!("Could not load prefs: {e}");
                Self::default()
            }
        }
    }

    /// Save to the OS config directory.
    pub fn save(&self) {
        if let Err(e) = Self::path().and_then(|p| {
            let yaml = serde_yaml::to_string(self).map_err(|e| anyhow::anyhow!(e))?;
            std::fs::write(&p, yaml)?;
            Ok(())
        }) {
            log::warn!("Could not save prefs: {e}");
        }
    }
}

#[cfg(test)]
mod tests;