graph_loom/persistence/
settings.rs1use std::fs;
2use std::io::{Read, Write};
3use std::path::PathBuf;
4
5use serde::{Deserialize, Serialize};
6
7use crate::api::auth::AuthConfig;
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
11pub enum StorageBackend {
12 Ron,
14 #[default]
16 Sqlite,
17}
18
19#[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#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
42pub enum EmbeddingModel {
43 TfIdf,
45 Word2Vec,
47 #[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 pub autosave_override: Option<PathBuf>,
58 #[serde(default)]
60 pub export_override: Option<PathBuf>,
61 #[serde(default)]
63 pub api_log_override: Option<PathBuf>,
64 #[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 #[serde(default)]
75 pub grpc_enabled: bool,
76 #[serde(default = "AppSettings::default_grpc_port")]
77 pub grpc_port: u16,
78 #[serde(default)]
80 pub background_on_close: bool,
81 #[serde(default)]
83 pub notes_dir_override: Option<PathBuf>,
84 #[serde(default)]
86 pub storage_backend: StorageBackend,
87 #[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 #[serde(default)]
98 pub auth_config: AuthConfig,
99 #[serde(default)]
101 pub embedding_model: EmbeddingModel,
102 #[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 #[cfg(target_os = "macos")]
137 {
138 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 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 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 #[cfg(target_os = "macos")]
164 {
165 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 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 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 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 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 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 pub fn settings_dir() -> PathBuf {
235 Self::config_dir()
236 }
237
238 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 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 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 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 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 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 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}