Skip to main content

graph_loom/persistence/
settings.rs

1use std::fs;
2use std::io::{Read, Write};
3use std::path::PathBuf;
4
5use serde::{Deserialize, Serialize};
6
7use crate::api::auth::AuthConfig;
8
9/// Storage backend selection for graph persistence
10#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
11pub enum StorageBackend {
12    /// RON text format (legacy, human-readable)
13    Ron,
14    /// SQLite database (ACID-compliant, scalable)
15    #[default]
16    Sqlite,
17}
18
19/// LLM provider selection for semantic features
20#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
21pub enum LlmProvider {
22    #[default]
23    None,
24    OpenAI,
25    Anthropic,
26    Ollama,
27}
28
29impl LlmProvider {
30    pub fn as_str(&self) -> &'static str {
31        match self {
32            LlmProvider::None => "None",
33            LlmProvider::OpenAI => "OpenAI",
34            LlmProvider::Anthropic => "Anthropic",
35            LlmProvider::Ollama => "Ollama",
36        }
37    }
38}
39
40/// Embedding model selection for semantic search
41#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
42pub enum EmbeddingModel {
43    /// TF-IDF based embeddings (fast, lightweight)
44    TfIdf,
45    /// Word2Vec style embeddings (learns from graph)
46    Word2Vec,
47    /// ONNX all-MiniLM-L6-v2 model (best quality)
48    #[default]
49    Onnx,
50}
51
52fn default_llm_model() -> String { "gpt-4o-mini".to_string() }
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
55pub struct AppSettings {
56    // If None, use OS default autosave directory
57    pub autosave_override: Option<PathBuf>,
58    // If None, use OS temporary directory for exports
59    #[serde(default)]
60    pub export_override: Option<PathBuf>,
61    // If None, server traffic logs go to OS temp dir
62    #[serde(default)]
63    pub api_log_override: Option<PathBuf>,
64    // API service configuration (actix)
65    #[serde(default)]
66    pub api_enabled: bool,
67    #[serde(default = "AppSettings::default_bind_addr")]
68    pub api_bind_addr: String,
69    #[serde(default = "AppSettings::default_port")]
70    pub api_port: u16,
71    #[serde(default)]
72    pub api_key: Option<String>,
73    // gRPC service configuration
74    #[serde(default)]
75    pub grpc_enabled: bool,
76    #[serde(default = "AppSettings::default_grpc_port")]
77    pub grpc_port: u16,
78    // Whether to continue running in background when GUI window is closed
79    #[serde(default)]
80    pub background_on_close: bool,
81    // Default directory for saving notes
82    #[serde(default)]
83    pub notes_dir_override: Option<PathBuf>,
84    // Storage backend selection (Ron or Sqlite)
85    #[serde(default)]
86    pub storage_backend: StorageBackend,
87    // LLM integration settings
88    #[serde(default)]
89    pub llm_provider: LlmProvider,
90    #[serde(default)]
91    pub llm_api_key: Option<String>,
92    #[serde(default = "default_llm_model")]
93    pub llm_model: String,
94    #[serde(default)]
95    pub llm_endpoint: Option<String>,
96    /// Authentication configuration for API access
97    #[serde(default)]
98    pub auth_config: AuthConfig,
99    /// Embedding model for semantic search
100    #[serde(default)]
101    pub embedding_model: EmbeddingModel,
102    /// Physics timeout in seconds (0 = indefinite movement)
103    #[serde(default = "AppSettings::default_physics_timeout")]
104    pub physics_timeout_secs: u64,
105}
106
107impl Default for AppSettings {
108    fn default() -> Self {
109        Self {
110            autosave_override: None,
111            export_override: None,
112            api_log_override: None,
113            api_enabled: false,
114            api_bind_addr: Self::default_bind_addr(),
115            api_port: Self::default_port(),
116            api_key: None,
117            grpc_enabled: false,
118            grpc_port: Self::default_grpc_port(),
119            background_on_close: false,
120            notes_dir_override: None,
121            storage_backend: StorageBackend::default(),
122            llm_provider: LlmProvider::default(),
123            llm_api_key: None,
124            llm_model: Self::default_llm_model(),
125            llm_endpoint: None,
126            auth_config: AuthConfig::default(),
127            embedding_model: EmbeddingModel::default(),
128            physics_timeout_secs: Self::default_physics_timeout(),
129        }
130    }
131}
132
133impl AppSettings {
134    fn config_dir() -> PathBuf {
135        // Cross-platform user config dir
136        #[cfg(target_os = "macos")]
137        {
138            // ~/Library/Application Support/Graph-Loom
139            let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("~"));
140            return home.join("Library").join("Application Support").join("Graph-Loom");
141        }
142        #[cfg(target_os = "windows")]
143        {
144            // %APPDATA%\Graph-Loom
145            if let Ok(appdata) = std::env::var("APPDATA") {
146                return PathBuf::from(appdata).join("Graph-Loom");
147            }
148            return PathBuf::from("Graph-Loom");
149        }
150        #[cfg(all(unix, not(target_os = "macos")))]
151        {
152            // $XDG_CONFIG_HOME/Graph-Loom or ~/.config/Graph-Loom
153            if let Ok(xdg) = std::env::var("XDG_CONFIG_HOME") {
154                return PathBuf::from(xdg).join("Graph-Loom");
155            }
156            let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("~"));
157            return home.join(".config").join("Graph-Loom");
158        }
159    }
160
161    fn autosave_default_dir() -> PathBuf {
162        // Cross-platform user-writable autosave dir
163        #[cfg(target_os = "macos")]
164        {
165            // Prefer system temp autosave like Sublime, else App Support
166            let tmp = std::env::var_os("TMPDIR").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("/tmp"));
167            return tmp.join("Graph-Loom");
168        }
169        #[cfg(target_os = "windows")]
170        {
171            // %LOCALAPPDATA%\Graph-Loom\Autosave else TEMP
172            if let Ok(local) = std::env::var("LOCALAPPDATA") {
173                return PathBuf::from(local).join("Graph-Loom").join("Autosave");
174            }
175            if let Ok(temp) = std::env::var("TEMP") {
176                return PathBuf::from(temp).join("Graph-Loom");
177            }
178            return PathBuf::from("Graph-Loom");
179        }
180        #[cfg(all(unix, not(target_os = "macos")))]
181        {
182            // $XDG_STATE_HOME/graph-loom or ~/.local/state/graph-loom, else /tmp/Graph-Loom
183            if let Ok(xdg) = std::env::var("XDG_STATE_HOME") {
184                return PathBuf::from(xdg).join("graph-loom");
185            }
186            if let Ok(home) = std::env::var("HOME") {
187                return PathBuf::from(home).join(".local").join("state").join("graph-loom");
188            }
189            return PathBuf::from("/tmp").join("Graph-Loom");
190        }
191    }
192
193    pub fn load() -> anyhow::Result<Self> {
194        // New JSON settings path
195        let json_path = Self::config_dir().join("settings.json");
196        if json_path.exists() {
197            let mut f = std::fs::File::open(json_path)?;
198            let mut s = String::new();
199            f.read_to_string(&mut s)?;
200            let v: Self = serde_json::from_str(&s)?;
201            return Ok(v);
202        }
203        // Migrate from legacy RON if present
204        let ron_path = Self::config_dir().join("settings.ron");
205        if ron_path.exists() {
206            let mut f = std::fs::File::open(&ron_path)?;
207            let mut s = String::new();
208            f.read_to_string(&mut s)?;
209            let v: Self = ron::from_str(&s)?;
210            // Save immediately to JSON for future reads, ignore errors silently
211            let _ = v.save();
212            return Ok(v);
213        }
214        Ok(Self::default())
215    }
216
217    pub fn save(&self) -> anyhow::Result<()> {
218        let dir = Self::config_dir();
219        fs::create_dir_all(&dir)?;
220        let path = dir.join("settings.json");
221        let s = serde_json::to_string_pretty(self)?;
222        let mut f = std::fs::File::create(path)?;
223        f.write_all(s.as_bytes())?;
224        Ok(())
225    }
226
227    pub fn autosave_dir(&self) -> PathBuf {
228        if let Some(p) = &self.autosave_override { return p.clone(); }
229        Self::autosave_default_dir()
230    }
231
232    /// Return the directory where the settings file (settings.json) is stored.
233    /// This is OS-specific and resolves to a per-user configuration directory.
234    pub fn settings_dir() -> PathBuf {
235        Self::config_dir()
236    }
237
238    /// Default export directory when no override is set: OS temporary directory.
239    /// Example: {temp_dir}/Graph-Loom/exports
240    pub fn export_default_dir() -> PathBuf {
241        let mut p = std::env::temp_dir();
242        p.push("Graph-Loom");
243        p.push("exports");
244        p
245    }
246
247    /// Effective export directory honoring user override or falling back to OS temp.
248    pub fn export_dir(&self) -> PathBuf {
249        if let Some(p) = &self.export_override { return p.clone(); }
250        Self::export_default_dir()
251    }
252
253    pub(crate) fn default_bind_addr() -> String { "127.0.0.1".to_string() }
254    pub(crate) fn default_port() -> u16 { 8787 }
255    pub(crate) fn default_grpc_port() -> u16 { 50051 }
256    pub(crate) fn default_llm_model() -> String { "gpt-4o-mini".to_string() }
257    /// Default physics timeout: 0 means indefinite (nodes move until settled)
258    pub(crate) fn default_physics_timeout() -> u64 { 0 }
259
260    pub fn api_endpoint(&self) -> String {
261        format!("{}:{}", self.api_bind_addr, self.api_port)
262    }
263
264    /// Default API log directory when no override is set: OS temporary directory.
265    /// Example: {temp_dir}/Graph-Loom/api-logs
266    pub fn api_log_default_dir() -> PathBuf {
267        let mut p = std::env::temp_dir();
268        p.push("Graph-Loom");
269        p.push("api-logs");
270        p
271    }
272
273    /// Effective API log directory honoring user override or falling back to OS temp.
274    pub fn api_log_dir(&self) -> PathBuf {
275        if let Some(p) = &self.api_log_override { return p.clone(); }
276        Self::api_log_default_dir()
277    }
278
279    /// Default notes directory when no override is set: ~/Documents/Graph-Loom/notes
280    pub fn notes_default_dir() -> PathBuf {
281        #[cfg(target_os = "macos")]
282        {
283            let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("~"));
284            return home.join("Documents").join("Graph-Loom").join("notes");
285        }
286        #[cfg(target_os = "windows")]
287        {
288            if let Ok(userprofile) = std::env::var("USERPROFILE") {
289                return PathBuf::from(userprofile).join("Documents").join("Graph-Loom").join("notes");
290            }
291            return PathBuf::from("Graph-Loom").join("notes");
292        }
293        #[cfg(all(unix, not(target_os = "macos")))]
294        {
295            let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("~"));
296            return home.join("Documents").join("Graph-Loom").join("notes");
297        }
298    }
299
300    /// Effective notes directory honoring user override or falling back to default.
301    pub fn notes_dir(&self) -> PathBuf {
302        if let Some(p) = &self.notes_dir_override { return p.clone(); }
303        Self::notes_default_dir()
304    }
305}